scsp-20200702/main.tea

/**
 *
 */
import Util;
import OpenApi;
import OpenApiUtil;
import EndpointUtil;

extends OpenApi;


init(config: OpenApi.Config){
  super(config);
  @endpointRule = 'central';
  @endpointMap = {
    cn-shanghai = 'scsp-vpc.cn-shanghai.aliyuncs.com',
  };

  checkConfig(config);
  @endpoint = getEndpoint('scsp', @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 DApp {
  baseAppCode?: string(name='BaseAppCode'),
  code?: string(name='Code'),
  containerAppCode?: string(name='ContainerAppCode'),
  containerDeploy?: boolean(name='ContainerDeploy'),
  gmtCreate?: long(name='GmtCreate'),
  id?: string(name='Id'),
  name?: string(name='Name'),
  remark?: string(name='Remark'),
}

model DAppArchive {
  app?: DApp(name='App'),
  appVersion?: string(name='AppVersion'),
  gmtCreate?: long(name='GmtCreate'),
  id?: string(name='Id'),
  resCount?: int32(name='ResCount'),
  status?: DPair(name='Status'),
  version?: string(name='Version'),
}

model DAppRes {
  code?: string(name='Code'),
  id?: string(name='Id'),
  name?: string(name='Name'),
  subType?: string(name='SubType'),
  type?: DPair(name='Type'),
}

model DAppResCount {
  items?: [ 
    {
      count?: int32(name='Count'),
      type?: DPair(name='Type'),
    }
  ](name='Items'),
  total?: int32(name='Total'),
}

model DDeploymentArchive {
  appCount?: int32(name='AppCount'),
  gmtCreate?: long(name='GmtCreate'),
  id?: string(name='Id'),
  name?: string(name='Name'),
  resCount?: int32(name='ResCount'),
  status?: DPair(name='Status'),
  version?: string(name='Version'),
}

model DPair {
}

model AnswerCallRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
}

model AnswerCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AnswerCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AnswerCallResponseBody(name='body'),
}

async function answerCallWithOptions(request: AnswerCallRequest, runtime: Util.RuntimeOptions): AnswerCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AnswerCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function answerCall(request: AnswerCallRequest): AnswerCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return answerCallWithOptions(request, runtime);
}

model AnwserAgentMonitorRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  callerParentId?: long(name='CallerParentId'),
  callerType?: string(name='CallerType'),
  callerUid?: long(name='CallerUid'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
  requestId?: string(name='RequestId'),
  stsTokenCallerUid?: long(name='StsTokenCallerUid'),
}

model AnwserAgentMonitorResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AnwserAgentMonitorResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AnwserAgentMonitorResponseBody(name='body'),
}

async function anwserAgentMonitorWithOptions(request: AnwserAgentMonitorRequest, runtime: Util.RuntimeOptions): AnwserAgentMonitorResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AnwserAgentMonitor',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function anwserAgentMonitor(request: AnwserAgentMonitorRequest): AnwserAgentMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return anwserAgentMonitorWithOptions(request, runtime);
}

model AppMessagePushRequest {
  expirationTime?: long(name='ExpirationTime'),
  instanceId?: string(name='InstanceId'),
  status?: int32(name='Status'),
  userId?: string(name='UserId'),
}

model AppMessagePushResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AppMessagePushResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AppMessagePushResponseBody(name='body'),
}

async function appMessagePushWithOptions(request: AppMessagePushRequest, runtime: Util.RuntimeOptions): AppMessagePushResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.expirationTime)) {
    query['ExpirationTime'] = request.expirationTime;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.status)) {
    query['Status'] = request.status;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'AppMessagePush',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function appMessagePush(request: AppMessagePushRequest): AppMessagePushResponse {
  var runtime = new Util.RuntimeOptions{};
  return appMessagePushWithOptions(request, runtime);
}

model AssignTicketRequest {
  acceptorId?: long(name='AcceptorId'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  operatorId?: long(name='OperatorId'),
  ticketId?: long(name='TicketId'),
}

model AssignTicketResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model AssignTicketResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: AssignTicketResponseBody(name='body'),
}

async function assignTicketWithOptions(request: AssignTicketRequest, runtime: Util.RuntimeOptions): AssignTicketResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.acceptorId)) {
    body['AcceptorId'] = request.acceptorId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operatorId)) {
    body['OperatorId'] = request.operatorId;
  }
  if (!Util.isUnset(request.ticketId)) {
    body['TicketId'] = request.ticketId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'AssignTicket',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function assignTicket(request: AssignTicketRequest): AssignTicketResponse {
  var runtime = new Util.RuntimeOptions{};
  return assignTicketWithOptions(request, runtime);
}

model BindAgentHotlinePhoneRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  phone?: string(name='Phone'),
  verifyCode?: string(name='VerifyCode'),
}

model BindAgentHotlinePhoneResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model BindAgentHotlinePhoneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: BindAgentHotlinePhoneResponseBody(name='body'),
}

async function bindAgentHotlinePhoneWithOptions(request: BindAgentHotlinePhoneRequest, runtime: Util.RuntimeOptions): BindAgentHotlinePhoneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.phone)) {
    body['Phone'] = request.phone;
  }
  if (!Util.isUnset(request.verifyCode)) {
    body['VerifyCode'] = request.verifyCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'BindAgentHotlinePhone',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function bindAgentHotlinePhone(request: BindAgentHotlinePhoneRequest): BindAgentHotlinePhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return bindAgentHotlinePhoneWithOptions(request, runtime);
}

model ChangeChatAgentStatusRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  method?: string(name='Method'),
}

model ChangeChatAgentStatusResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ChangeChatAgentStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ChangeChatAgentStatusResponseBody(name='body'),
}

async function changeChatAgentStatusWithOptions(request: ChangeChatAgentStatusRequest, runtime: Util.RuntimeOptions): ChangeChatAgentStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.method)) {
    body['Method'] = request.method;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ChangeChatAgentStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function changeChatAgentStatus(request: ChangeChatAgentStatusRequest): ChangeChatAgentStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return changeChatAgentStatusWithOptions(request, runtime);
}

model CloseTicketRequest {
  actionItems?: string(name='ActionItems'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  operatorId?: long(name='OperatorId'),
  ticketId?: long(name='TicketId'),
}

model CloseTicketResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CloseTicketResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CloseTicketResponseBody(name='body'),
}

async function closeTicketWithOptions(request: CloseTicketRequest, runtime: Util.RuntimeOptions): CloseTicketResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.actionItems)) {
    body['ActionItems'] = request.actionItems;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operatorId)) {
    body['OperatorId'] = request.operatorId;
  }
  if (!Util.isUnset(request.ticketId)) {
    body['TicketId'] = request.ticketId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CloseTicket',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function closeTicket(request: CloseTicketRequest): CloseTicketResponse {
  var runtime = new Util.RuntimeOptions{};
  return closeTicketWithOptions(request, runtime);
}

model CollectDeploymentArchiveRequest {
  deploymentCode?: string(name='DeploymentCode'),
  envType?: int32(name='EnvType'),
  name?: string(name='Name'),
}

model CollectDeploymentArchiveResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CollectDeploymentArchiveResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CollectDeploymentArchiveResponseBody(name='body'),
}

async function collectDeploymentArchiveWithOptions(request: CollectDeploymentArchiveRequest, runtime: Util.RuntimeOptions): CollectDeploymentArchiveResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CollectDeploymentArchive',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function collectDeploymentArchive(request: CollectDeploymentArchiveRequest): CollectDeploymentArchiveResponse {
  var runtime = new Util.RuntimeOptions{};
  return collectDeploymentArchiveWithOptions(request, runtime);
}

model CreateAgentRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  displayName?: string(name='DisplayName'),
  instanceId?: string(name='InstanceId'),
  skillGroupId?: [ long ](name='SkillGroupId'),
  skillGroupIdList?: [ long ](name='SkillGroupIdList'),
}

model CreateAgentResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateAgentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateAgentResponseBody(name='body'),
}

async function createAgentWithOptions(request: CreateAgentRequest, runtime: Util.RuntimeOptions): CreateAgentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.displayName)) {
    body['DisplayName'] = request.displayName;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var bodyFlat : map[string]any = {};
  if (!Util.isUnset(request.skillGroupId)) {
    bodyFlat['SkillGroupId'] = request.skillGroupId;
  }
  if (!Util.isUnset(request.skillGroupIdList)) {
    bodyFlat['SkillGroupIdList'] = request.skillGroupIdList;
  }
  body = {
    ...body,
    ...OpenApiUtil.query(bodyFlat),
  };

  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateAgent',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createAgent(request: CreateAgentRequest): CreateAgentResponse {
  var runtime = new Util.RuntimeOptions{};
  return createAgentWithOptions(request, runtime);
}

model CreateCustomerRequest {
  bizType?: string(name='BizType'),
  contacter?: string(name='Contacter'),
  dingding?: string(name='Dingding'),
  email?: string(name='Email'),
  industry?: string(name='Industry'),
  instanceId?: string(name='InstanceId'),
  managerName?: string(name='ManagerName'),
  name?: string(name='Name'),
  outerId?: string(name='OuterId'),
  outerIdType?: int32(name='OuterIdType'),
  phone?: string(name='Phone'),
  position?: string(name='Position'),
  prodLineId?: long(name='ProdLineId'),
  typeCode?: string(name='TypeCode'),
}

model CreateCustomerResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateCustomerResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateCustomerResponseBody(name='body'),
}

async function createCustomerWithOptions(request: CreateCustomerRequest, runtime: Util.RuntimeOptions): CreateCustomerResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.contacter)) {
    query['Contacter'] = request.contacter;
  }
  if (!Util.isUnset(request.dingding)) {
    query['Dingding'] = request.dingding;
  }
  if (!Util.isUnset(request.email)) {
    query['Email'] = request.email;
  }
  if (!Util.isUnset(request.industry)) {
    query['Industry'] = request.industry;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.managerName)) {
    query['ManagerName'] = request.managerName;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.outerId)) {
    query['OuterId'] = request.outerId;
  }
  if (!Util.isUnset(request.outerIdType)) {
    query['OuterIdType'] = request.outerIdType;
  }
  if (!Util.isUnset(request.phone)) {
    query['Phone'] = request.phone;
  }
  if (!Util.isUnset(request.position)) {
    query['Position'] = request.position;
  }
  if (!Util.isUnset(request.prodLineId)) {
    query['ProdLineId'] = request.prodLineId;
  }
  if (!Util.isUnset(request.typeCode)) {
    query['TypeCode'] = request.typeCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateCustomer',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createCustomer(request: CreateCustomerRequest): CreateCustomerResponse {
  var runtime = new Util.RuntimeOptions{};
  return createCustomerWithOptions(request, runtime);
}

model CreateDeploymentTaskRequest {
  appArchiveIds?: [ string ](name='AppArchiveIds'),
  deploymentArchiveId?: string(name='DeploymentArchiveId'),
  deploymentCode?: string(name='DeploymentCode'),
  envType?: string(name='EnvType'),
}

model CreateDeploymentTaskShrinkRequest {
  appArchiveIdsShrink?: string(name='AppArchiveIds'),
  deploymentArchiveId?: string(name='DeploymentArchiveId'),
  deploymentCode?: string(name='DeploymentCode'),
  envType?: string(name='EnvType'),
}

model CreateDeploymentTaskResponseBody = {
  code?: string(name='Code'),
  data?: {
    deploymentArchive?: DDeploymentArchive(name='DeploymentArchive'),
    gmtCreate?: long(name='GmtCreate'),
    id?: string(name='Id'),
    name?: string(name='Name'),
    status?: DPair(name='Status'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateDeploymentTaskResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateDeploymentTaskResponseBody(name='body'),
}

async function createDeploymentTaskWithOptions(tmpReq: CreateDeploymentTaskRequest, runtime: Util.RuntimeOptions): CreateDeploymentTaskResponse {
  Util.validateModel(tmpReq);
  var request = new CreateDeploymentTaskShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.appArchiveIds)) {
    request.appArchiveIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.appArchiveIds, 'AppArchiveIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateDeploymentTask',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createDeploymentTask(request: CreateDeploymentTaskRequest): CreateDeploymentTaskResponse {
  var runtime = new Util.RuntimeOptions{};
  return createDeploymentTaskWithOptions(request, runtime);
}

model CreateEntityIvrRouteRequest {
  departmentId?: string(name='DepartmentId'),
  entityBizCode?: string(name='EntityBizCode'),
  entityBizCodeType?: string(name='EntityBizCodeType'),
  entityId?: string(name='EntityId'),
  entityName?: string(name='EntityName'),
  entityRelationNumber?: string(name='EntityRelationNumber'),
  extInfo?: string(name='ExtInfo'),
  groupId?: long(name='GroupId'),
  instanceId?: string(name='InstanceId'),
  serviceId?: long(name='ServiceId'),
}

model CreateEntityIvrRouteResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateEntityIvrRouteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateEntityIvrRouteResponseBody(name='body'),
}

async function createEntityIvrRouteWithOptions(request: CreateEntityIvrRouteRequest, runtime: Util.RuntimeOptions): CreateEntityIvrRouteResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.departmentId)) {
    body['DepartmentId'] = request.departmentId;
  }
  if (!Util.isUnset(request.entityBizCode)) {
    body['EntityBizCode'] = request.entityBizCode;
  }
  if (!Util.isUnset(request.entityBizCodeType)) {
    body['EntityBizCodeType'] = request.entityBizCodeType;
  }
  if (!Util.isUnset(request.entityId)) {
    body['EntityId'] = request.entityId;
  }
  if (!Util.isUnset(request.entityName)) {
    body['EntityName'] = request.entityName;
  }
  if (!Util.isUnset(request.entityRelationNumber)) {
    body['EntityRelationNumber'] = request.entityRelationNumber;
  }
  if (!Util.isUnset(request.extInfo)) {
    body['ExtInfo'] = request.extInfo;
  }
  if (!Util.isUnset(request.groupId)) {
    body['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.serviceId)) {
    body['ServiceId'] = request.serviceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateEntityIvrRoute',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createEntityIvrRoute(request: CreateEntityIvrRouteRequest): CreateEntityIvrRouteResponse {
  var runtime = new Util.RuntimeOptions{};
  return createEntityIvrRouteWithOptions(request, runtime);
}

model CreateOuterCallCenterDataRequest {
  bizId?: string(name='BizId'),
  bizType?: string(name='BizType'),
  callType?: string(name='CallType'),
  endReason?: string(name='EndReason'),
  extInfo?: string(name='ExtInfo'),
  fromPhoneNum?: string(name='FromPhoneNum'),
  instanceId?: string(name='InstanceId'),
  interveneTime?: string(name='InterveneTime'),
  recordUrl?: string(name='RecordUrl'),
  sessionId?: string(name='SessionId'),
  tenantId?: string(name='TenantId'),
  toPhoneNum?: string(name='ToPhoneNum'),
  userInfo?: string(name='UserInfo'),
}

model CreateOuterCallCenterDataResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateOuterCallCenterDataResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateOuterCallCenterDataResponseBody(name='body'),
}

async function createOuterCallCenterDataWithOptions(request: CreateOuterCallCenterDataRequest, runtime: Util.RuntimeOptions): CreateOuterCallCenterDataResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.bizId)) {
    body['BizId'] = request.bizId;
  }
  if (!Util.isUnset(request.bizType)) {
    body['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.callType)) {
    body['CallType'] = request.callType;
  }
  if (!Util.isUnset(request.endReason)) {
    body['EndReason'] = request.endReason;
  }
  if (!Util.isUnset(request.extInfo)) {
    body['ExtInfo'] = request.extInfo;
  }
  if (!Util.isUnset(request.fromPhoneNum)) {
    body['FromPhoneNum'] = request.fromPhoneNum;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.interveneTime)) {
    body['InterveneTime'] = request.interveneTime;
  }
  if (!Util.isUnset(request.recordUrl)) {
    body['RecordUrl'] = request.recordUrl;
  }
  if (!Util.isUnset(request.sessionId)) {
    body['SessionId'] = request.sessionId;
  }
  if (!Util.isUnset(request.tenantId)) {
    body['TenantId'] = request.tenantId;
  }
  if (!Util.isUnset(request.toPhoneNum)) {
    body['ToPhoneNum'] = request.toPhoneNum;
  }
  if (!Util.isUnset(request.userInfo)) {
    body['UserInfo'] = request.userInfo;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateOuterCallCenterData',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createOuterCallCenterData(request: CreateOuterCallCenterDataRequest): CreateOuterCallCenterDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return createOuterCallCenterDataWithOptions(request, runtime);
}

model CreateRoleRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  operator?: string(name='Operator'),
  permissionId?: [ long ](name='PermissionId'),
  roleName?: string(name='RoleName'),
}

model CreateRoleResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateRoleResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateRoleResponseBody(name='body'),
}

async function createRoleWithOptions(request: CreateRoleRequest, runtime: Util.RuntimeOptions): CreateRoleResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operator)) {
    body['Operator'] = request.operator;
  }
  if (!Util.isUnset(request.permissionId)) {
    body['PermissionId'] = request.permissionId;
  }
  if (!Util.isUnset(request.roleName)) {
    body['RoleName'] = request.roleName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateRole',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createRole(request: CreateRoleRequest): CreateRoleResponse {
  var runtime = new Util.RuntimeOptions{};
  return createRoleWithOptions(request, runtime);
}

model CreateSkillGroupRequest {
  channelType?: int32(name='ChannelType'),
  clientToken?: string(name='ClientToken'),
  description?: string(name='Description'),
  displayName?: string(name='DisplayName'),
  instanceId?: string(name='InstanceId'),
  skillGroupName?: string(name='SkillGroupName'),
}

model CreateSkillGroupResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateSkillGroupResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateSkillGroupResponseBody(name='body'),
}

async function createSkillGroupWithOptions(request: CreateSkillGroupRequest, runtime: Util.RuntimeOptions): CreateSkillGroupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.channelType)) {
    body['ChannelType'] = request.channelType;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.description)) {
    body['Description'] = request.description;
  }
  if (!Util.isUnset(request.displayName)) {
    body['DisplayName'] = request.displayName;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.skillGroupName)) {
    body['SkillGroupName'] = request.skillGroupName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateSkillGroup',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createSkillGroup(request: CreateSkillGroupRequest): CreateSkillGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSkillGroupWithOptions(request, runtime);
}

model CreateSubTicketRequest {
  agentId?: long(name='AgentId'),
  bizData?: string(name='BizData'),
  creatorId?: long(name='CreatorId'),
  creatorName?: string(name='CreatorName'),
  formData?: string(name='FormData'),
  fromInfo?: string(name='FromInfo'),
  instanceId?: string(name='InstanceId'),
  memberId?: long(name='MemberId'),
  memberName?: string(name='MemberName'),
  parentCaseId?: long(name='ParentCaseId'),
  priority?: int32(name='Priority'),
  templateId?: long(name='TemplateId'),
}

model CreateSubTicketResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateSubTicketResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateSubTicketResponseBody(name='body'),
}

async function createSubTicketWithOptions(request: CreateSubTicketRequest, runtime: Util.RuntimeOptions): CreateSubTicketResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.agentId)) {
    query['AgentId'] = request.agentId;
  }
  if (!Util.isUnset(request.bizData)) {
    query['BizData'] = request.bizData;
  }
  if (!Util.isUnset(request.creatorId)) {
    query['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.creatorName)) {
    query['CreatorName'] = request.creatorName;
  }
  if (!Util.isUnset(request.formData)) {
    query['FormData'] = request.formData;
  }
  if (!Util.isUnset(request.fromInfo)) {
    query['FromInfo'] = request.fromInfo;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.memberId)) {
    query['MemberId'] = request.memberId;
  }
  if (!Util.isUnset(request.memberName)) {
    query['MemberName'] = request.memberName;
  }
  if (!Util.isUnset(request.parentCaseId)) {
    query['ParentCaseId'] = request.parentCaseId;
  }
  if (!Util.isUnset(request.priority)) {
    query['Priority'] = request.priority;
  }
  if (!Util.isUnset(request.templateId)) {
    query['TemplateId'] = request.templateId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'CreateSubTicket',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createSubTicket(request: CreateSubTicketRequest): CreateSubTicketResponse {
  var runtime = new Util.RuntimeOptions{};
  return createSubTicketWithOptions(request, runtime);
}

model CreateThirdSsoAgentRequest {
  accountId?: string(name='AccountId'),
  accountName?: string(name='AccountName'),
  clientId?: string(name='ClientId'),
  clientToken?: string(name='ClientToken'),
  displayName?: string(name='DisplayName'),
  instanceId?: string(name='InstanceId'),
  roleIds?: [ long ](name='RoleIds'),
  skillGroupIds?: [ long ](name='SkillGroupIds'),
}

model CreateThirdSsoAgentResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateThirdSsoAgentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateThirdSsoAgentResponseBody(name='body'),
}

async function createThirdSsoAgentWithOptions(request: CreateThirdSsoAgentRequest, runtime: Util.RuntimeOptions): CreateThirdSsoAgentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountId)) {
    body['AccountId'] = request.accountId;
  }
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientId)) {
    body['ClientId'] = request.clientId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.displayName)) {
    body['DisplayName'] = request.displayName;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var bodyFlat : map[string]any = {};
  if (!Util.isUnset(request.roleIds)) {
    bodyFlat['RoleIds'] = request.roleIds;
  }
  if (!Util.isUnset(request.skillGroupIds)) {
    bodyFlat['SkillGroupIds'] = request.skillGroupIds;
  }
  body = {
    ...body,
    ...OpenApiUtil.query(bodyFlat),
  };

  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateThirdSsoAgent',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createThirdSsoAgent(request: CreateThirdSsoAgentRequest): CreateThirdSsoAgentResponse {
  var runtime = new Util.RuntimeOptions{};
  return createThirdSsoAgentWithOptions(request, runtime);
}

model CreateTicketRequest {
  carbonCopy?: string(name='CarbonCopy'),
  categoryId?: long(name='CategoryId'),
  clientToken?: string(name='ClientToken'),
  creatorId?: long(name='CreatorId'),
  creatorName?: string(name='CreatorName'),
  creatorType?: int32(name='CreatorType'),
  formData?: string(name='FormData'),
  fromInfo?: string(name='FromInfo'),
  instanceId?: string(name='InstanceId'),
  memberId?: long(name='MemberId'),
  memberName?: string(name='MemberName'),
  priority?: int32(name='Priority'),
  templateId?: long(name='TemplateId'),
}

model CreateTicketResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTicketResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTicketResponseBody(name='body'),
}

async function createTicketWithOptions(request: CreateTicketRequest, runtime: Util.RuntimeOptions): CreateTicketResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.carbonCopy)) {
    body['CarbonCopy'] = request.carbonCopy;
  }
  if (!Util.isUnset(request.categoryId)) {
    body['CategoryId'] = request.categoryId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.creatorName)) {
    body['CreatorName'] = request.creatorName;
  }
  if (!Util.isUnset(request.creatorType)) {
    body['CreatorType'] = request.creatorType;
  }
  if (!Util.isUnset(request.formData)) {
    body['FormData'] = request.formData;
  }
  if (!Util.isUnset(request.fromInfo)) {
    body['FromInfo'] = request.fromInfo;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.memberId)) {
    body['MemberId'] = request.memberId;
  }
  if (!Util.isUnset(request.memberName)) {
    body['MemberName'] = request.memberName;
  }
  if (!Util.isUnset(request.priority)) {
    body['Priority'] = request.priority;
  }
  if (!Util.isUnset(request.templateId)) {
    body['TemplateId'] = request.templateId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'CreateTicket',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTicket(request: CreateTicketRequest): CreateTicketResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTicketWithOptions(request, runtime);
}

model DeleteAgentRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model DeleteAgentResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteAgentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteAgentResponseBody(name='body'),
}

async function deleteAgentWithOptions(request: DeleteAgentRequest, runtime: Util.RuntimeOptions): DeleteAgentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.accountName)) {
    query['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'DeleteAgent',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'DELETE',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteAgent(request: DeleteAgentRequest): DeleteAgentResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteAgentWithOptions(request, runtime);
}

model DeleteEntityRouteRequest {
  instanceId?: string(name='InstanceId'),
  uniqueId?: long(name='UniqueId'),
}

model DeleteEntityRouteResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DeleteEntityRouteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DeleteEntityRouteResponseBody(name='body'),
}

async function deleteEntityRouteWithOptions(request: DeleteEntityRouteRequest, runtime: Util.RuntimeOptions): DeleteEntityRouteResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.uniqueId)) {
    body['UniqueId'] = request.uniqueId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DeleteEntityRoute',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function deleteEntityRoute(request: DeleteEntityRouteRequest): DeleteEntityRouteResponse {
  var runtime = new Util.RuntimeOptions{};
  return deleteEntityRouteWithOptions(request, runtime);
}

model DisableRoleRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  roleId?: long(name='RoleId'),
}

model DisableRoleResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model DisableRoleResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: DisableRoleResponseBody(name='body'),
}

async function disableRoleWithOptions(request: DisableRoleRequest, runtime: Util.RuntimeOptions): DisableRoleResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.roleId)) {
    body['RoleId'] = request.roleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'DisableRole',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function disableRole(request: DisableRoleRequest): DisableRoleResponse {
  var runtime = new Util.RuntimeOptions{};
  return disableRoleWithOptions(request, runtime);
}

model EVENTQUERYRequest {
  appName?: string(name='appName'),
  token?: string(name='token'),
}

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

model EVENTQUERYResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: EVENTQUERYResponseBody(name='body'),
}

async function eVENTQUERYWithOptions(request: EVENTQUERYRequest, runtime: Util.RuntimeOptions): EVENTQUERYResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'EVENTQUERY',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function eVENTQUERY(request: EVENTQUERYRequest): EVENTQUERYResponse {
  var runtime = new Util.RuntimeOptions{};
  return eVENTQUERYWithOptions(request, runtime);
}

model EditEntityRouteRequest {
  departmentId?: string(name='DepartmentId'),
  entityBizCode?: string(name='EntityBizCode'),
  entityBizCodeType?: string(name='EntityBizCodeType'),
  entityId?: string(name='EntityId'),
  entityName?: string(name='EntityName'),
  entityRelationNumber?: string(name='EntityRelationNumber'),
  extInfo?: string(name='ExtInfo'),
  groupId?: long(name='GroupId'),
  instanceId?: string(name='InstanceId'),
  serviceId?: long(name='ServiceId'),
  uniqueId?: long(name='UniqueId'),
}

model EditEntityRouteResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model EditEntityRouteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: EditEntityRouteResponseBody(name='body'),
}

async function editEntityRouteWithOptions(request: EditEntityRouteRequest, runtime: Util.RuntimeOptions): EditEntityRouteResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.departmentId)) {
    body['DepartmentId'] = request.departmentId;
  }
  if (!Util.isUnset(request.entityBizCode)) {
    body['EntityBizCode'] = request.entityBizCode;
  }
  if (!Util.isUnset(request.entityBizCodeType)) {
    body['EntityBizCodeType'] = request.entityBizCodeType;
  }
  if (!Util.isUnset(request.entityId)) {
    body['EntityId'] = request.entityId;
  }
  if (!Util.isUnset(request.entityName)) {
    body['EntityName'] = request.entityName;
  }
  if (!Util.isUnset(request.entityRelationNumber)) {
    body['EntityRelationNumber'] = request.entityRelationNumber;
  }
  if (!Util.isUnset(request.extInfo)) {
    body['ExtInfo'] = request.extInfo;
  }
  if (!Util.isUnset(request.groupId)) {
    body['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.serviceId)) {
    body['ServiceId'] = request.serviceId;
  }
  if (!Util.isUnset(request.uniqueId)) {
    body['UniqueId'] = request.uniqueId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'EditEntityRoute',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function editEntityRoute(request: EditEntityRouteRequest): EditEntityRouteResponse {
  var runtime = new Util.RuntimeOptions{};
  return editEntityRouteWithOptions(request, runtime);
}

model EnableRoleRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  roleId?: long(name='RoleId'),
}

model EnableRoleResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model EnableRoleResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: EnableRoleResponseBody(name='body'),
}

async function enableRoleWithOptions(request: EnableRoleRequest, runtime: Util.RuntimeOptions): EnableRoleResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.roleId)) {
    body['RoleId'] = request.roleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'EnableRole',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function enableRole(request: EnableRoleRequest): EnableRoleResponse {
  var runtime = new Util.RuntimeOptions{};
  return enableRoleWithOptions(request, runtime);
}

model ExecuteActivityRequest {
  activityCode?: string(name='ActivityCode'),
  activityForm?: string(name='ActivityForm'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  operatorId?: long(name='OperatorId'),
  ticketId?: long(name='TicketId'),
}

model ExecuteActivityResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ExecuteActivityResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ExecuteActivityResponseBody(name='body'),
}

async function executeActivityWithOptions(request: ExecuteActivityRequest, runtime: Util.RuntimeOptions): ExecuteActivityResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.activityCode)) {
    body['ActivityCode'] = request.activityCode;
  }
  if (!Util.isUnset(request.activityForm)) {
    body['ActivityForm'] = request.activityForm;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operatorId)) {
    body['OperatorId'] = request.operatorId;
  }
  if (!Util.isUnset(request.ticketId)) {
    body['TicketId'] = request.ticketId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'ExecuteActivity',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function executeActivity(request: ExecuteActivityRequest): ExecuteActivityResponse {
  var runtime = new Util.RuntimeOptions{};
  return executeActivityWithOptions(request, runtime);
}

model FetchCallRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  holdConnectionId?: string(name='HoldConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
}

model FetchCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model FetchCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: FetchCallResponseBody(name='body'),
}

async function fetchCallWithOptions(request: FetchCallRequest, runtime: Util.RuntimeOptions): FetchCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.holdConnectionId)) {
    body['HoldConnectionId'] = request.holdConnectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'FetchCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function fetchCall(request: FetchCallRequest): FetchCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return fetchCallWithOptions(request, runtime);
}

model FinishHotlineServiceRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model FinishHotlineServiceResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model FinishHotlineServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: FinishHotlineServiceResponseBody(name='body'),
}

async function finishHotlineServiceWithOptions(request: FinishHotlineServiceRequest, runtime: Util.RuntimeOptions): FinishHotlineServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'FinishHotlineService',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function finishHotlineService(request: FinishHotlineServiceRequest): FinishHotlineServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return finishHotlineServiceWithOptions(request, runtime);
}

model FinishHotlineServiceNewRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model FinishHotlineServiceNewResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model FinishHotlineServiceNewResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: FinishHotlineServiceNewResponseBody(name='body'),
}

async function finishHotlineServiceNewWithOptions(request: FinishHotlineServiceNewRequest, runtime: Util.RuntimeOptions): FinishHotlineServiceNewResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'FinishHotlineServiceNew',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function finishHotlineServiceNew(request: FinishHotlineServiceNewRequest): FinishHotlineServiceNewResponse {
  var runtime = new Util.RuntimeOptions{};
  return finishHotlineServiceNewWithOptions(request, runtime);
}

model GenerateWebSocketSignRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GenerateWebSocketSignResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GenerateWebSocketSignResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GenerateWebSocketSignResponseBody(name='body'),
}

async function generateWebSocketSignWithOptions(request: GenerateWebSocketSignRequest, runtime: Util.RuntimeOptions): GenerateWebSocketSignResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GenerateWebSocketSign',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function generateWebSocketSign(request: GenerateWebSocketSignRequest): GenerateWebSocketSignResponse {
  var runtime = new Util.RuntimeOptions{};
  return generateWebSocketSignWithOptions(request, runtime);
}

model GetAgentRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetAgentResponseBody = {
  code?: string(name='Code'),
  data?: {
    accountName?: string(name='AccountName'),
    agentId?: long(name='AgentId'),
    displayName?: string(name='DisplayName'),
    groupList?: [ 
      {
        channelType?: int32(name='ChannelType'),
        description?: string(name='Description'),
        displayName?: string(name='DisplayName'),
        name?: string(name='Name'),
        skillGroupId?: long(name='SkillGroupId'),
      }
    ](name='GroupList'),
    status?: int32(name='Status'),
    tenantId?: long(name='TenantId'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAgentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentResponseBody(name='body'),
}

async function getAgentWithOptions(request: GetAgentRequest, runtime: Util.RuntimeOptions): GetAgentResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAgent',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgent(request: GetAgentRequest): GetAgentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentWithOptions(request, runtime);
}

model GetAgentBasisStatusRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetAgentBasisStatusShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetAgentBasisStatusResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetAgentBasisStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentBasisStatusResponseBody(name='body'),
}

async function getAgentBasisStatusWithOptions(tmpReq: GetAgentBasisStatusRequest, runtime: Util.RuntimeOptions): GetAgentBasisStatusResponse {
  Util.validateModel(tmpReq);
  var request = new GetAgentBasisStatusShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAgentBasisStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgentBasisStatus(request: GetAgentBasisStatusRequest): GetAgentBasisStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentBasisStatusWithOptions(request, runtime);
}

model GetAgentDetailReportRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetAgentDetailReportShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetAgentDetailReportResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: long(name='PageNum'),
    pageSize?: long(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: long(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetAgentDetailReportResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentDetailReportResponseBody(name='body'),
}

async function getAgentDetailReportWithOptions(tmpReq: GetAgentDetailReportRequest, runtime: Util.RuntimeOptions): GetAgentDetailReportResponse {
  Util.validateModel(tmpReq);
  var request = new GetAgentDetailReportShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAgentDetailReport',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgentDetailReport(request: GetAgentDetailReportRequest): GetAgentDetailReportResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentDetailReportWithOptions(request, runtime);
}

model GetAgentHotlineRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetAgentHotlineResponseBody = {
  code?: string(name='Code'),
  data?: {
    accountName?: string(name='AccountName'),
    agentId?: long(name='AgentId'),
    agentPhone?: string(name='AgentPhone'),
    departmentId?: string(name='DepartmentId'),
    displayName?: string(name='DisplayName'),
    extAttr?: string(name='ExtAttr'),
    groupList?: [ 
      {
        displayName?: string(name='DisplayName'),
        name?: string(name='Name'),
        skillGroupId?: long(name='SkillGroupId'),
      }
    ](name='GroupList'),
    skillGroups?: string(name='SkillGroups'),
    tenantId?: long(name='TenantId'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAgentHotlineResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentHotlineResponseBody(name='body'),
}

async function getAgentHotlineWithOptions(request: GetAgentHotlineRequest, runtime: Util.RuntimeOptions): GetAgentHotlineResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetAgentHotline',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgentHotline(request: GetAgentHotlineRequest): GetAgentHotlineResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentHotlineWithOptions(request, runtime);
}

model GetAgentHotlinePhoneRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetAgentHotlinePhoneResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAgentHotlinePhoneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentHotlinePhoneResponseBody(name='body'),
}

async function getAgentHotlinePhoneWithOptions(request: GetAgentHotlinePhoneRequest, runtime: Util.RuntimeOptions): GetAgentHotlinePhoneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetAgentHotlinePhone',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgentHotlinePhone(request: GetAgentHotlinePhoneRequest): GetAgentHotlinePhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentHotlinePhoneWithOptions(request, runtime);
}

model GetAgentServiceStatusRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetAgentServiceStatusShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetAgentServiceStatusResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: long(name='PageNum'),
    pageSize?: long(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: long(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAgentServiceStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentServiceStatusResponseBody(name='body'),
}

async function getAgentServiceStatusWithOptions(tmpReq: GetAgentServiceStatusRequest, runtime: Util.RuntimeOptions): GetAgentServiceStatusResponse {
  Util.validateModel(tmpReq);
  var request = new GetAgentServiceStatusShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAgentServiceStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgentServiceStatus(request: GetAgentServiceStatusRequest): GetAgentServiceStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentServiceStatusWithOptions(request, runtime);
}

model GetAgentStatisticsRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetAgentStatisticsShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetAgentStatisticsResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetAgentStatisticsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentStatisticsResponseBody(name='body'),
}

async function getAgentStatisticsWithOptions(tmpReq: GetAgentStatisticsRequest, runtime: Util.RuntimeOptions): GetAgentStatisticsResponse {
  Util.validateModel(tmpReq);
  var request = new GetAgentStatisticsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAgentStatistics',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgentStatistics(request: GetAgentStatisticsRequest): GetAgentStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentStatisticsWithOptions(request, runtime);
}

model GetAgentWorkStatusRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetAgentWorkStatusResponseBody = {
  code?: string(name='Code'),
  data?: {
    accountName?: string(name='AccountName'),
    agentId?: long(name='AgentId'),
    agentStatusCode?: string(name='AgentStatusCode'),
    agentStatusDesc?: string(name='AgentStatusDesc'),
    extAttr?: string(name='ExtAttr'),
    tenantId?: long(name='TenantId'),
    workChannel?: string(name='WorkChannel'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAgentWorkStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAgentWorkStatusResponseBody(name='body'),
}

async function getAgentWorkStatusWithOptions(request: GetAgentWorkStatusRequest, runtime: Util.RuntimeOptions): GetAgentWorkStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetAgentWorkStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAgentWorkStatus(request: GetAgentWorkStatusRequest): GetAgentWorkStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAgentWorkStatusWithOptions(request, runtime);
}

model GetAllDepartmentRequest {
  instanceId?: string(name='InstanceId'),
}

model GetAllDepartmentResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      departmentId?: long(name='DepartmentId'),
      departmentName?: string(name='DepartmentName'),
      status?: int32(name='Status'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAllDepartmentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAllDepartmentResponseBody(name='body'),
}

async function getAllDepartmentWithOptions(request: GetAllDepartmentRequest, runtime: Util.RuntimeOptions): GetAllDepartmentResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAllDepartment',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAllDepartment(request: GetAllDepartmentRequest): GetAllDepartmentResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAllDepartmentWithOptions(request, runtime);
}

model GetAppArchivesRequest {
  deploymentArchiveId?: string(name='DeploymentArchiveId'),
}

model GetAppArchivesResponseBody = {
  code?: string(name='Code'),
  data?: [
    DAppArchive
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAppArchivesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAppArchivesResponseBody(name='body'),
}

async function getAppArchivesWithOptions(request: GetAppArchivesRequest, runtime: Util.RuntimeOptions): GetAppArchivesResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAppArchives',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAppArchives(request: GetAppArchivesRequest): GetAppArchivesResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAppArchivesWithOptions(request, runtime);
}

model GetAppTasksRequest {
  deploymentTaskId?: string(name='deploymentTaskId'),
}

model GetAppTasksResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      appArchive?: DAppArchive(name='AppArchive'),
      baseAppArchive?: DAppArchive(name='BaseAppArchive'),
      gmtCreate?: long(name='GmtCreate'),
      gmtModified?: long(name='GmtModified'),
      id?: string(name='Id'),
      name?: string(name='Name'),
      pendingResCount?: DAppResCount(name='PendingResCount'),
      resCount?: DAppResCount(name='ResCount'),
      status?: DPair(name='Status'),
    }
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAppTasksResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAppTasksResponseBody(name='body'),
}

async function getAppTasksWithOptions(request: GetAppTasksRequest, runtime: Util.RuntimeOptions): GetAppTasksResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAppTasks',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAppTasks(request: GetAppTasksRequest): GetAppTasksResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAppTasksWithOptions(request, runtime);
}

model GetAuthInfoRequest {
  appKey?: string(name='AppKey'),
  foreignId?: string(name='ForeignId'),
  instanceId?: string(name='InstanceId'),
}

model GetAuthInfoResponseBody = {
  code?: string(name='Code'),
  data?: {
    app?: string(name='App'),
    appKey?: string(name='AppKey'),
    appName?: string(name='AppName'),
    code?: string(name='Code'),
    sessionId?: string(name='SessionId'),
    tenantId?: string(name='TenantId'),
    time?: long(name='Time'),
    userId?: string(name='UserId'),
    userName?: string(name='UserName'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetAuthInfoResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetAuthInfoResponseBody(name='body'),
}

async function getAuthInfoWithOptions(request: GetAuthInfoRequest, runtime: Util.RuntimeOptions): GetAuthInfoResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.appKey)) {
    query['AppKey'] = request.appKey;
  }
  if (!Util.isUnset(request.foreignId)) {
    query['ForeignId'] = request.foreignId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetAuthInfo',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getAuthInfo(request: GetAuthInfoRequest): GetAuthInfoResponse {
  var runtime = new Util.RuntimeOptions{};
  return getAuthInfoWithOptions(request, runtime);
}

model GetByForeignIdRequest {
  foreignId?: string(name='ForeignId'),
  instanceId?: string(name='InstanceId'),
  sourceId?: long(name='SourceId'),
}

model GetByForeignIdResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetByForeignIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetByForeignIdResponseBody(name='body'),
}

async function getByForeignIdWithOptions(request: GetByForeignIdRequest, runtime: Util.RuntimeOptions): GetByForeignIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.foreignId)) {
    query['ForeignId'] = request.foreignId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.sourceId)) {
    query['SourceId'] = request.sourceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetByForeignId',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getByForeignId(request: GetByForeignIdRequest): GetByForeignIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getByForeignIdWithOptions(request, runtime);
}

model GetCMSIdByForeignIdRequest {
  foreignId?: string(name='ForeignId'),
  instanceId?: string(name='InstanceId'),
  nick?: string(name='Nick'),
  sourceId?: long(name='SourceId'),
}

model GetCMSIdByForeignIdResponseBody = {
  code?: string(name='Code'),
  data?: {
    anonymity?: boolean(name='Anonymity'),
    avatar?: string(name='Avatar'),
    customerTypeId?: int32(name='CustomerTypeId'),
    foreignId?: string(name='ForeignId'),
    gender?: string(name='Gender'),
    nick?: string(name='Nick'),
    phone?: string(name='Phone'),
    status?: int32(name='Status'),
    userId?: string(name='UserId'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetCMSIdByForeignIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCMSIdByForeignIdResponseBody(name='body'),
}

async function getCMSIdByForeignIdWithOptions(request: GetCMSIdByForeignIdRequest, runtime: Util.RuntimeOptions): GetCMSIdByForeignIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.foreignId)) {
    query['ForeignId'] = request.foreignId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.nick)) {
    query['Nick'] = request.nick;
  }
  if (!Util.isUnset(request.sourceId)) {
    query['SourceId'] = request.sourceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCMSIdByForeignId',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCMSIdByForeignId(request: GetCMSIdByForeignIdRequest): GetCMSIdByForeignIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCMSIdByForeignIdWithOptions(request, runtime);
}

model GetCallsPerDayRequest {
  dataId?: string(name='DataId'),
  dataIdEnd?: string(name='DataIdEnd'),
  dataIdStart?: string(name='DataIdStart'),
  havePhoneNumbers?: string(name='HavePhoneNumbers'),
  hourId?: string(name='HourId'),
  instanceId?: string(name='InstanceId'),
  minuteId?: string(name='MinuteId'),
  pageNo?: long(name='PageNo'),
  pageSize?: long(name='PageSize'),
  phoneNumbers?: string(name='PhoneNumbers'),
}

model GetCallsPerDayResponseBody = {
  code?: string(name='Code'),
  data?: {
    callsPerdayResponseList?: [ 
      {
        callInCnt?: string(name='CallInCnt'),
        callOutCnt?: string(name='CallOutCnt'),
        dataId?: string(name='DataId'),
        hourId?: string(name='HourId'),
        minuteId?: string(name='MinuteId'),
        phoneNum?: string(name='PhoneNum'),
        tenantId?: string(name='TenantId'),
        tenantName?: string(name='TenantName'),
      }
    ](name='CallsPerdayResponseList'),
    pageNo?: string(name='PageNo'),
    pageSize?: long(name='PageSize'),
    totalNum?: long(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetCallsPerDayResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetCallsPerDayResponseBody(name='body'),
}

async function getCallsPerDayWithOptions(request: GetCallsPerDayRequest, runtime: Util.RuntimeOptions): GetCallsPerDayResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetCallsPerDay',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getCallsPerDay(request: GetCallsPerDayRequest): GetCallsPerDayResponse {
  var runtime = new Util.RuntimeOptions{};
  return getCallsPerDayWithOptions(request, runtime);
}

model GetDepartmentalLatitudeAgentStatusRequest {
  currentPage?: long(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: long(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetDepartmentalLatitudeAgentStatusShrinkRequest {
  currentPage?: long(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  instanceId?: string(name='InstanceId'),
  pageSize?: long(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetDepartmentalLatitudeAgentStatusResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetDepartmentalLatitudeAgentStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetDepartmentalLatitudeAgentStatusResponseBody(name='body'),
}

async function getDepartmentalLatitudeAgentStatusWithOptions(tmpReq: GetDepartmentalLatitudeAgentStatusRequest, runtime: Util.RuntimeOptions): GetDepartmentalLatitudeAgentStatusResponse {
  Util.validateModel(tmpReq);
  var request = new GetDepartmentalLatitudeAgentStatusShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDepartmentalLatitudeAgentStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDepartmentalLatitudeAgentStatus(request: GetDepartmentalLatitudeAgentStatusRequest): GetDepartmentalLatitudeAgentStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDepartmentalLatitudeAgentStatusWithOptions(request, runtime);
}

model GetDeploymentArchiveRequest {
  deploymentArchiveId?: string(name='deploymentArchiveId'),
}

model GetDeploymentArchiveResponseBody = {
  code?: string(name='Code'),
  data?: DDeploymentArchive(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetDeploymentArchiveResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetDeploymentArchiveResponseBody(name='body'),
}

async function getDeploymentArchiveWithOptions(request: GetDeploymentArchiveRequest, runtime: Util.RuntimeOptions): GetDeploymentArchiveResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetDeploymentArchive',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getDeploymentArchive(request: GetDeploymentArchiveRequest): GetDeploymentArchiveResponse {
  var runtime = new Util.RuntimeOptions{};
  return getDeploymentArchiveWithOptions(request, runtime);
}

model GetEntityRouteRequest {
  entityBizCode?: string(name='EntityBizCode'),
  entityId?: string(name='EntityId'),
  entityName?: string(name='EntityName'),
  entityRelationNumber?: string(name='EntityRelationNumber'),
  instanceId?: string(name='InstanceId'),
  uniqueId?: long(name='UniqueId'),
}

model GetEntityRouteResponseBody = {
  code?: string(name='Code'),
  data?: {
    departmentId?: string(name='DepartmentId'),
    entityBizCode?: string(name='EntityBizCode'),
    entityBizCodeType?: string(name='EntityBizCodeType'),
    entityId?: string(name='EntityId'),
    entityName?: string(name='EntityName'),
    entityRelationNumber?: string(name='EntityRelationNumber'),
    extInfo?: string(name='ExtInfo'),
    groupId?: long(name='GroupId'),
    serviceId?: long(name='ServiceId'),
    uniqueId?: long(name='UniqueId'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetEntityRouteResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetEntityRouteResponseBody(name='body'),
}

async function getEntityRouteWithOptions(request: GetEntityRouteRequest, runtime: Util.RuntimeOptions): GetEntityRouteResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.entityBizCode)) {
    body['EntityBizCode'] = request.entityBizCode;
  }
  if (!Util.isUnset(request.entityId)) {
    body['EntityId'] = request.entityId;
  }
  if (!Util.isUnset(request.entityName)) {
    body['EntityName'] = request.entityName;
  }
  if (!Util.isUnset(request.entityRelationNumber)) {
    body['EntityRelationNumber'] = request.entityRelationNumber;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.uniqueId)) {
    body['UniqueId'] = request.uniqueId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetEntityRoute',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEntityRoute(request: GetEntityRouteRequest): GetEntityRouteResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEntityRouteWithOptions(request, runtime);
}

model GetEntityRouteListRequest {
  entityName?: string(name='EntityName'),
  entityRelationNumber?: string(name='EntityRelationNumber'),
  instanceId?: string(name='InstanceId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
}

model GetEntityRouteListResponseBody = {
  code?: string(name='Code'),
  data?: {
    entityRouteList?: [ 
      {
        departmentId?: string(name='DepartmentId'),
        entityBizCode?: string(name='EntityBizCode'),
        entityBizCodeType?: string(name='EntityBizCodeType'),
        entityId?: string(name='EntityId'),
        entityName?: string(name='EntityName'),
        entityRelationNumber?: string(name='EntityRelationNumber'),
        extInfo?: string(name='ExtInfo'),
        groupId?: string(name='GroupId'),
        serviceId?: string(name='ServiceId'),
        uniqueId?: long(name='UniqueId'),
      }
    ](name='EntityRouteList'),
    pageNo?: int32(name='PageNo'),
    pageSize?: int32(name='PageSize'),
    total?: long(name='Total'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetEntityRouteListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetEntityRouteListResponseBody(name='body'),
}

async function getEntityRouteListWithOptions(request: GetEntityRouteListRequest, runtime: Util.RuntimeOptions): GetEntityRouteListResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.entityName)) {
    body['EntityName'] = request.entityName;
  }
  if (!Util.isUnset(request.entityRelationNumber)) {
    body['EntityRelationNumber'] = request.entityRelationNumber;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetEntityRouteList',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEntityRouteList(request: GetEntityRouteListRequest): GetEntityRouteListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEntityRouteListWithOptions(request, runtime);
}

model GetEntityTagRelationRequest {
  entityId?: string(name='EntityId'),
  entityType?: string(name='EntityType'),
  instanceId?: string(name='InstanceId'),
}

model GetEntityTagRelationResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      entityId?: string(name='EntityId'),
      entityType?: string(name='EntityType'),
      tagCode?: string(name='TagCode'),
      tagGroupCode?: string(name='TagGroupCode'),
      tagGroupName?: string(name='TagGroupName'),
      tagName?: string(name='TagName'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetEntityTagRelationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetEntityTagRelationResponseBody(name='body'),
}

async function getEntityTagRelationWithOptions(request: GetEntityTagRelationRequest, runtime: Util.RuntimeOptions): GetEntityTagRelationResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.entityId)) {
    body['EntityId'] = request.entityId;
  }
  if (!Util.isUnset(request.entityType)) {
    body['EntityType'] = request.entityType;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetEntityTagRelation',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getEntityTagRelation(request: GetEntityTagRelationRequest): GetEntityTagRelationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getEntityTagRelationWithOptions(request, runtime);
}

model GetForeignIdByCMSIdRequest {
  instanceId?: string(name='InstanceId'),
  userId?: long(name='UserId'),
}

model GetForeignIdByCMSIdResponseBody = {
  data?: {
    anonymity?: boolean(name='Anonymity'),
    avatar?: string(name='Avatar'),
    code?: string(name='Code'),
    customerTypeId?: int32(name='CustomerTypeId'),
    foreignId?: string(name='ForeignId'),
    gender?: string(name='Gender'),
    nick?: string(name='Nick'),
    phone?: string(name='Phone'),
    status?: int32(name='Status'),
    success?: boolean(name='Success'),
    userId?: string(name='UserId'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
}

model GetForeignIdByCMSIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetForeignIdByCMSIdResponseBody(name='body'),
}

async function getForeignIdByCMSIdWithOptions(request: GetForeignIdByCMSIdRequest, runtime: Util.RuntimeOptions): GetForeignIdByCMSIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.userId)) {
    query['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetForeignIdByCMSId',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getForeignIdByCMSId(request: GetForeignIdByCMSIdRequest): GetForeignIdByCMSIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getForeignIdByCMSIdWithOptions(request, runtime);
}

model GetGrantedRoleIdsRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetGrantedRoleIdsResponseBody = {
  code?: string(name='Code'),
  data?: [ long ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetGrantedRoleIdsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetGrantedRoleIdsResponseBody(name='body'),
}

async function getGrantedRoleIdsWithOptions(request: GetGrantedRoleIdsRequest, runtime: Util.RuntimeOptions): GetGrantedRoleIdsResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetGrantedRoleIds',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getGrantedRoleIds(request: GetGrantedRoleIdsRequest): GetGrantedRoleIdsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getGrantedRoleIdsWithOptions(request, runtime);
}

model GetHotlineAgentDetailRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetHotlineAgentDetailResponseBody = {
  code?: string(name='Code'),
  data?: {
    agentId?: long(name='AgentId'),
    agentStatus?: int32(name='AgentStatus'),
    agentStatusCode?: string(name='AgentStatusCode'),
    assigned?: boolean(name='Assigned'),
    restType?: int32(name='RestType'),
    tenantId?: long(name='TenantId'),
    token?: string(name='Token'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetHotlineAgentDetailResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHotlineAgentDetailResponseBody(name='body'),
}

async function getHotlineAgentDetailWithOptions(request: GetHotlineAgentDetailRequest, runtime: Util.RuntimeOptions): GetHotlineAgentDetailResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotlineAgentDetail',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHotlineAgentDetail(request: GetHotlineAgentDetailRequest): GetHotlineAgentDetailResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotlineAgentDetailWithOptions(request, runtime);
}

model GetHotlineAgentDetailReportRequest {
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetHotlineAgentDetailReportResponseBody = {
  code?: string(name='Code'),
  data?: {
    columns?: [ 
      {
        key?: string(name='Key'),
        title?: string(name='Title'),
      }
    ](name='Columns'),
    page?: int32(name='Page'),
    pageSize?: int32(name='PageSize'),
    rows?: [  map[string]any ](name='Rows'),
    total?: int32(name='Total'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetHotlineAgentDetailReportResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHotlineAgentDetailReportResponseBody(name='body'),
}

async function getHotlineAgentDetailReportWithOptions(request: GetHotlineAgentDetailReportRequest, runtime: Util.RuntimeOptions): GetHotlineAgentDetailReportResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.depIds)) {
    query['DepIds'] = request.depIds;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.groupIds)) {
    query['GroupIds'] = request.groupIds;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotlineAgentDetailReport',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHotlineAgentDetailReport(request: GetHotlineAgentDetailReportRequest): GetHotlineAgentDetailReportResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotlineAgentDetailReportWithOptions(request, runtime);
}

model GetHotlineAgentDetailWithChannelRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetHotlineAgentDetailWithChannelResponseBody = {
  code?: string(name='Code'),
  data?: {
    agentId?: long(name='AgentId'),
    agentStatus?: int32(name='AgentStatus'),
    agentStatusCode?: string(name='AgentStatusCode'),
    assigned?: boolean(name='Assigned'),
    extAttr?: string(name='ExtAttr'),
    restType?: int32(name='RestType'),
    tenantId?: long(name='TenantId'),
    token?: string(name='Token'),
    workChannel?: string(name='WorkChannel'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetHotlineAgentDetailWithChannelResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHotlineAgentDetailWithChannelResponseBody(name='body'),
}

async function getHotlineAgentDetailWithChannelWithOptions(request: GetHotlineAgentDetailWithChannelRequest, runtime: Util.RuntimeOptions): GetHotlineAgentDetailWithChannelResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotlineAgentDetailWithChannel',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHotlineAgentDetailWithChannel(request: GetHotlineAgentDetailWithChannelRequest): GetHotlineAgentDetailWithChannelResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotlineAgentDetailWithChannelWithOptions(request, runtime);
}

model GetHotlineAgentStatusRequest {
  accountName?: string(name='AccountName'),
  instanceId?: string(name='InstanceId'),
}

model GetHotlineAgentStatusResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetHotlineAgentStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHotlineAgentStatusResponseBody(name='body'),
}

async function getHotlineAgentStatusWithOptions(request: GetHotlineAgentStatusRequest, runtime: Util.RuntimeOptions): GetHotlineAgentStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetHotlineAgentStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHotlineAgentStatus(request: GetHotlineAgentStatusRequest): GetHotlineAgentStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotlineAgentStatusWithOptions(request, runtime);
}

model GetHotlineGroupDetailReportRequest {
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetHotlineGroupDetailReportResponseBody = {
  code?: string(name='Code'),
  data?: {
    columns?: [ 
      {
        key?: string(name='Key'),
        title?: string(name='Title'),
      }
    ](name='Columns'),
    page?: int32(name='Page'),
    pageSize?: int32(name='PageSize'),
    rows?: [  map[string]any ](name='Rows'),
    total?: int32(name='Total'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetHotlineGroupDetailReportResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHotlineGroupDetailReportResponseBody(name='body'),
}

async function getHotlineGroupDetailReportWithOptions(request: GetHotlineGroupDetailReportRequest, runtime: Util.RuntimeOptions): GetHotlineGroupDetailReportResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.currentPage)) {
    query['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.depIds)) {
    query['DepIds'] = request.depIds;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.groupIds)) {
    query['GroupIds'] = request.groupIds;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotlineGroupDetailReport',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHotlineGroupDetailReport(request: GetHotlineGroupDetailReportRequest): GetHotlineGroupDetailReportResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotlineGroupDetailReportWithOptions(request, runtime);
}

model GetHotlineServiceStatisticsRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetHotlineServiceStatisticsShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetHotlineServiceStatisticsResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetHotlineServiceStatisticsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHotlineServiceStatisticsResponseBody(name='body'),
}

async function getHotlineServiceStatisticsWithOptions(tmpReq: GetHotlineServiceStatisticsRequest, runtime: Util.RuntimeOptions): GetHotlineServiceStatisticsResponse {
  Util.validateModel(tmpReq);
  var request = new GetHotlineServiceStatisticsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotlineServiceStatistics',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHotlineServiceStatistics(request: GetHotlineServiceStatisticsRequest): GetHotlineServiceStatisticsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotlineServiceStatisticsWithOptions(request, runtime);
}

model GetHotlineWaitingNumberRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetHotlineWaitingNumberResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetHotlineWaitingNumberResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetHotlineWaitingNumberResponseBody(name='body'),
}

async function getHotlineWaitingNumberWithOptions(request: GetHotlineWaitingNumberRequest, runtime: Util.RuntimeOptions): GetHotlineWaitingNumberResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetHotlineWaitingNumber',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getHotlineWaitingNumber(request: GetHotlineWaitingNumberRequest): GetHotlineWaitingNumberResponse {
  var runtime = new Util.RuntimeOptions{};
  return getHotlineWaitingNumberWithOptions(request, runtime);
}

model GetNumLocationRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  phoneNum?: string(name='PhoneNum'),
}

model GetNumLocationResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetNumLocationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetNumLocationResponseBody(name='body'),
}

async function getNumLocationWithOptions(request: GetNumLocationRequest, runtime: Util.RuntimeOptions): GetNumLocationResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetNumLocation',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getNumLocation(request: GetNumLocationRequest): GetNumLocationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getNumLocationWithOptions(request, runtime);
}

model GetOnlineSeatInformationRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetOnlineSeatInformationShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetOnlineSeatInformationResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetOnlineSeatInformationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOnlineSeatInformationResponseBody(name='body'),
}

async function getOnlineSeatInformationWithOptions(tmpReq: GetOnlineSeatInformationRequest, runtime: Util.RuntimeOptions): GetOnlineSeatInformationResponse {
  Util.validateModel(tmpReq);
  var request = new GetOnlineSeatInformationShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetOnlineSeatInformation',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOnlineSeatInformation(request: GetOnlineSeatInformationRequest): GetOnlineSeatInformationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOnlineSeatInformationWithOptions(request, runtime);
}

model GetOnlineServiceVolumeRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetOnlineServiceVolumeShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetOnlineServiceVolumeResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetOnlineServiceVolumeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOnlineServiceVolumeResponseBody(name='body'),
}

async function getOnlineServiceVolumeWithOptions(tmpReq: GetOnlineServiceVolumeRequest, runtime: Util.RuntimeOptions): GetOnlineServiceVolumeResponse {
  Util.validateModel(tmpReq);
  var request = new GetOnlineServiceVolumeShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetOnlineServiceVolume',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOnlineServiceVolume(request: GetOnlineServiceVolumeRequest): GetOnlineServiceVolumeResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOnlineServiceVolumeWithOptions(request, runtime);
}

model GetOnlineTouchSessionListRequest {
  clientToken?: string(name='ClientToken'),
  currentPage?: int32(name='CurrentPage'),
  endDate?: long(name='EndDate'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetOnlineTouchSessionListResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      channelId?: string(name='ChannelId'),
      firstTime?: long(name='FirstTime'),
      groupId?: string(name='GroupId'),
      groupName?: string(name='GroupName'),
      messageInfo?: [ 
        {
          content?: string(name='Content'),
          gmtCreated?: string(name='GmtCreated'),
          messageId?: long(name='MessageId'),
          senderId?: string(name='SenderId'),
          senderName?: string(name='SenderName'),
          senderType?: string(name='SenderType'),
          status?: string(name='Status'),
        }
      ](name='MessageInfo'),
      sessionId?: string(name='SessionId'),
      touchId?: string(name='TouchId'),
      userForeignId?: string(name='UserForeignId'),
    }
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalResults?: int32(name='TotalResults'),
}

model GetOnlineTouchSessionListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOnlineTouchSessionListResponseBody(name='body'),
}

async function getOnlineTouchSessionListWithOptions(request: GetOnlineTouchSessionListRequest, runtime: Util.RuntimeOptions): GetOnlineTouchSessionListResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.endDate)) {
    body['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.groupIds)) {
    body['GroupIds'] = request.groupIds;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.startDate)) {
    body['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOnlineTouchSessionList',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOnlineTouchSessionList(request: GetOnlineTouchSessionListRequest): GetOnlineTouchSessionListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOnlineTouchSessionListWithOptions(request, runtime);
}

model GetOutbounNumListRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model GetOutbounNumListResponseBody = {
  code?: string(name='Code'),
  data?: {
    num?: [ 
      {
        description?: string(name='Description'),
        type?: int32(name='Type'),
        value?: string(name='Value'),
      }
    ](name='Num'),
    numGroup?: [ 
      {
        description?: string(name='Description'),
        type?: int32(name='Type'),
        value?: string(name='Value'),
      }
    ](name='NumGroup'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetOutbounNumListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOutbounNumListResponseBody(name='body'),
}

async function getOutbounNumListWithOptions(request: GetOutbounNumListRequest, runtime: Util.RuntimeOptions): GetOutbounNumListResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOutbounNumList',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOutbounNumList(request: GetOutbounNumListRequest): GetOutbounNumListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOutbounNumListWithOptions(request, runtime);
}

model GetOuterCallCenterDataListRequest {
  bizId?: string(name='BizId'),
  fromPhoneNum?: string(name='FromPhoneNum'),
  instanceId?: string(name='InstanceId'),
  queryEndTime?: string(name='QueryEndTime'),
  queryStartTime?: string(name='QueryStartTime'),
  sessionId?: string(name='SessionId'),
  toPhoneNum?: string(name='ToPhoneNum'),
}

model GetOuterCallCenterDataListResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      acid?: string(name='Acid'),
      bizId?: string(name='BizId'),
      bizType?: string(name='BizType'),
      callType?: string(name='CallType'),
      endReason?: string(name='EndReason'),
      extInfo?: string(name='ExtInfo'),
      fromPhoneNum?: string(name='FromPhoneNum'),
      interveneTime?: string(name='InterveneTime'),
      sessionId?: string(name='SessionId'),
      toPhoneNum?: string(name='ToPhoneNum'),
      userInfo?: string(name='UserInfo'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetOuterCallCenterDataListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetOuterCallCenterDataListResponseBody(name='body'),
}

async function getOuterCallCenterDataListWithOptions(request: GetOuterCallCenterDataListRequest, runtime: Util.RuntimeOptions): GetOuterCallCenterDataListResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.bizId)) {
    body['BizId'] = request.bizId;
  }
  if (!Util.isUnset(request.fromPhoneNum)) {
    body['FromPhoneNum'] = request.fromPhoneNum;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.queryEndTime)) {
    body['QueryEndTime'] = request.queryEndTime;
  }
  if (!Util.isUnset(request.queryStartTime)) {
    body['QueryStartTime'] = request.queryStartTime;
  }
  if (!Util.isUnset(request.sessionId)) {
    body['SessionId'] = request.sessionId;
  }
  if (!Util.isUnset(request.toPhoneNum)) {
    body['ToPhoneNum'] = request.toPhoneNum;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetOuterCallCenterDataList',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getOuterCallCenterDataList(request: GetOuterCallCenterDataListRequest): GetOuterCallCenterDataListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getOuterCallCenterDataListWithOptions(request, runtime);
}

model GetQueueInformationRequest {
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetQueueInformationShrinkRequest {
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetQueueInformationResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetQueueInformationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetQueueInformationResponseBody(name='body'),
}

async function getQueueInformationWithOptions(tmpReq: GetQueueInformationRequest, runtime: Util.RuntimeOptions): GetQueueInformationResponse {
  Util.validateModel(tmpReq);
  var request = new GetQueueInformationShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetQueueInformation',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getQueueInformation(request: GetQueueInformationRequest): GetQueueInformationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getQueueInformationWithOptions(request, runtime);
}

model GetSeatInformationRequest {
  instanceId?: string(name='InstanceId'),
  currentPage?: int32(name='currentPage'),
  depIds?: [ long ](name='depIds'),
  endDate?: long(name='endDate'),
  existDepartmentGrouping?: boolean(name='existDepartmentGrouping'),
  pageSize?: int32(name='pageSize'),
  startDate?: long(name='startDate'),
}

model GetSeatInformationShrinkRequest {
  instanceId?: string(name='InstanceId'),
  currentPage?: int32(name='currentPage'),
  depIdsShrink?: string(name='depIds'),
  endDate?: long(name='endDate'),
  existDepartmentGrouping?: boolean(name='existDepartmentGrouping'),
  pageSize?: int32(name='pageSize'),
  startDate?: long(name='startDate'),
}

model GetSeatInformationResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rowr?: string(name='Rowr'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetSeatInformationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSeatInformationResponseBody(name='body'),
}

async function getSeatInformationWithOptions(tmpReq: GetSeatInformationRequest, runtime: Util.RuntimeOptions): GetSeatInformationResponse {
  Util.validateModel(tmpReq);
  var request = new GetSeatInformationShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'depIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSeatInformation',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSeatInformation(request: GetSeatInformationRequest): GetSeatInformationResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSeatInformationWithOptions(request, runtime);
}

model GetSkillGroupAgentStatusDetailsRequest {
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupAgentStatusDetailsShrinkRequest {
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupAgentStatusDetailsResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: long(name='PageNum'),
    pageSize?: long(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: long(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetSkillGroupAgentStatusDetailsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSkillGroupAgentStatusDetailsResponseBody(name='body'),
}

async function getSkillGroupAgentStatusDetailsWithOptions(tmpReq: GetSkillGroupAgentStatusDetailsRequest, runtime: Util.RuntimeOptions): GetSkillGroupAgentStatusDetailsResponse {
  Util.validateModel(tmpReq);
  var request = new GetSkillGroupAgentStatusDetailsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSkillGroupAgentStatusDetails',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSkillGroupAgentStatusDetails(request: GetSkillGroupAgentStatusDetailsRequest): GetSkillGroupAgentStatusDetailsResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSkillGroupAgentStatusDetailsWithOptions(request, runtime);
}

model GetSkillGroupAndAgentStatusSummaryRequest {
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupAndAgentStatusSummaryShrinkRequest {
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupAndAgentStatusSummaryResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetSkillGroupAndAgentStatusSummaryResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSkillGroupAndAgentStatusSummaryResponseBody(name='body'),
}

async function getSkillGroupAndAgentStatusSummaryWithOptions(tmpReq: GetSkillGroupAndAgentStatusSummaryRequest, runtime: Util.RuntimeOptions): GetSkillGroupAndAgentStatusSummaryResponse {
  Util.validateModel(tmpReq);
  var request = new GetSkillGroupAndAgentStatusSummaryShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSkillGroupAndAgentStatusSummary',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSkillGroupAndAgentStatusSummary(request: GetSkillGroupAndAgentStatusSummaryRequest): GetSkillGroupAndAgentStatusSummaryResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSkillGroupAndAgentStatusSummaryWithOptions(request, runtime);
}

model GetSkillGroupLatitudeStateRequest {
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupLatitudeStateShrinkRequest {
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupLatitudeStateResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetSkillGroupLatitudeStateResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSkillGroupLatitudeStateResponseBody(name='body'),
}

async function getSkillGroupLatitudeStateWithOptions(tmpReq: GetSkillGroupLatitudeStateRequest, runtime: Util.RuntimeOptions): GetSkillGroupLatitudeStateResponse {
  Util.validateModel(tmpReq);
  var request = new GetSkillGroupLatitudeStateShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSkillGroupLatitudeState',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSkillGroupLatitudeState(request: GetSkillGroupLatitudeStateRequest): GetSkillGroupLatitudeStateResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSkillGroupLatitudeStateWithOptions(request, runtime);
}

model GetSkillGroupServiceCapabilityRequest {
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupServiceCapabilityShrinkRequest {
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
}

model GetSkillGroupServiceCapabilityResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: long(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetSkillGroupServiceCapabilityResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSkillGroupServiceCapabilityResponseBody(name='body'),
}

async function getSkillGroupServiceCapabilityWithOptions(tmpReq: GetSkillGroupServiceCapabilityRequest, runtime: Util.RuntimeOptions): GetSkillGroupServiceCapabilityResponse {
  Util.validateModel(tmpReq);
  var request = new GetSkillGroupServiceCapabilityShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSkillGroupServiceCapability',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSkillGroupServiceCapability(request: GetSkillGroupServiceCapabilityRequest): GetSkillGroupServiceCapabilityResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSkillGroupServiceCapabilityWithOptions(request, runtime);
}

model GetSkillGroupServiceStatusRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existChannelInstanceGrouping?: boolean(name='ExistChannelInstanceGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existRobotInstanceGrouping?: boolean(name='ExistRobotInstanceGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetSkillGroupServiceStatusShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existChannelInstanceGrouping?: boolean(name='ExistChannelInstanceGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existRobotInstanceGrouping?: boolean(name='ExistRobotInstanceGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetSkillGroupServiceStatusResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: int32(name='PageNum'),
    pageSize?: int32(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: int32(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetSkillGroupServiceStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSkillGroupServiceStatusResponseBody(name='body'),
}

async function getSkillGroupServiceStatusWithOptions(tmpReq: GetSkillGroupServiceStatusRequest, runtime: Util.RuntimeOptions): GetSkillGroupServiceStatusResponse {
  Util.validateModel(tmpReq);
  var request = new GetSkillGroupServiceStatusShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSkillGroupServiceStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSkillGroupServiceStatus(request: GetSkillGroupServiceStatusRequest): GetSkillGroupServiceStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSkillGroupServiceStatusWithOptions(request, runtime);
}

model GetSkillGroupStatusTotalRequest {
  agentIds?: [ long ](name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIds?: [ long ](name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIds?: [ long ](name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetSkillGroupStatusTotalShrinkRequest {
  agentIdsShrink?: string(name='AgentIds'),
  currentPage?: int32(name='CurrentPage'),
  depIdsShrink?: string(name='DepIds'),
  endDate?: long(name='EndDate'),
  existAgentGrouping?: boolean(name='ExistAgentGrouping'),
  existDepartmentGrouping?: boolean(name='ExistDepartmentGrouping'),
  existSkillGroupGrouping?: boolean(name='ExistSkillGroupGrouping'),
  groupIdsShrink?: string(name='GroupIds'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  timeLatitudeType?: string(name='TimeLatitudeType'),
}

model GetSkillGroupStatusTotalResponseBody = {
  code?: string(name='Code'),
  data?: {
    pageNum?: long(name='PageNum'),
    pageSize?: long(name='PageSize'),
    rows?: string(name='Rows'),
    totalNum?: long(name='TotalNum'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: string(name='Success'),
}

model GetSkillGroupStatusTotalResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetSkillGroupStatusTotalResponseBody(name='body'),
}

async function getSkillGroupStatusTotalWithOptions(tmpReq: GetSkillGroupStatusTotalRequest, runtime: Util.RuntimeOptions): GetSkillGroupStatusTotalResponse {
  Util.validateModel(tmpReq);
  var request = new GetSkillGroupStatusTotalShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.agentIds)) {
    request.agentIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.agentIds, 'AgentIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.depIds)) {
    request.depIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.depIds, 'DepIds', 'simple');
  }
  if (!Util.isUnset(tmpReq.groupIds)) {
    request.groupIdsShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.groupIds, 'GroupIds', 'simple');
  }
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetSkillGroupStatusTotal',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getSkillGroupStatusTotal(request: GetSkillGroupStatusTotalRequest): GetSkillGroupStatusTotalResponse {
  var runtime = new Util.RuntimeOptions{};
  return getSkillGroupStatusTotalWithOptions(request, runtime);
}

model GetTagListRequest {
  entityId?: string(name='EntityId'),
  entityType?: string(name='EntityType'),
  instanceId?: string(name='InstanceId'),
}

model GetTagListResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      scenarioCode?: string(name='ScenarioCode'),
      tagGroupCode?: string(name='TagGroupCode'),
      tagGroupName?: string(name='TagGroupName'),
      tagValues?: [ 
        {
          description?: string(name='Description'),
          entityRelationNumber?: string(name='EntityRelationNumber'),
          status?: string(name='Status'),
          tagCode?: string(name='TagCode'),
          tagGroupCode?: string(name='TagGroupCode'),
          tagGroupName?: string(name='TagGroupName'),
          tagName?: string(name='TagName'),
        }
      ](name='TagValues'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTagListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTagListResponseBody(name='body'),
}

async function getTagListWithOptions(request: GetTagListRequest, runtime: Util.RuntimeOptions): GetTagListResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.entityId)) {
    body['EntityId'] = request.entityId;
  }
  if (!Util.isUnset(request.entityType)) {
    body['EntityType'] = request.entityType;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTagList',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTagList(request: GetTagListRequest): GetTagListResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTagListWithOptions(request, runtime);
}

model GetTicketByCaseIdRequest {
  caseId?: long(name='CaseId'),
  instanceId?: string(name='InstanceId'),
}

model GetTicketByCaseIdResponseBody = {
  code?: string(name='Code'),
  data?: {
    buId?: long(name='BuId'),
    caseId?: long(name='CaseId'),
    caseStatus?: int32(name='CaseStatus'),
    caseType?: int32(name='CaseType'),
    channelId?: string(name='ChannelId'),
    departmentId?: long(name='DepartmentId'),
    endTime?: long(name='EndTime'),
    extAttrs?: map[string]any(name='ExtAttrs'),
    fromInfo?: string(name='FromInfo'),
    gmtCreate?: long(name='GmtCreate'),
    gmtModified?: long(name='GmtModified'),
    memberId?: long(name='MemberId'),
    memberName?: string(name='MemberName'),
    owner?: long(name='Owner'),
    ownerName?: string(name='OwnerName'),
    parentId?: long(name='ParentId'),
    priority?: int32(name='Priority'),
    questionId?: string(name='QuestionId'),
    questionInfo?: string(name='QuestionInfo'),
    sopCateId?: long(name='SopCateId'),
    srType?: long(name='SrType'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTicketByCaseIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTicketByCaseIdResponseBody(name='body'),
}

async function getTicketByCaseIdWithOptions(request: GetTicketByCaseIdRequest, runtime: Util.RuntimeOptions): GetTicketByCaseIdResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.caseId)) {
    body['CaseId'] = request.caseId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetTicketByCaseId',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTicketByCaseId(request: GetTicketByCaseIdRequest): GetTicketByCaseIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTicketByCaseIdWithOptions(request, runtime);
}

model GetTicketTemplateSchemaRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  templateId?: long(name='TemplateId'),
}

model GetTicketTemplateSchemaResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetTicketTemplateSchemaResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetTicketTemplateSchemaResponseBody(name='body'),
}

async function getTicketTemplateSchemaWithOptions(request: GetTicketTemplateSchemaRequest, runtime: Util.RuntimeOptions): GetTicketTemplateSchemaResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'GetTicketTemplateSchema',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getTicketTemplateSchema(request: GetTicketTemplateSchemaRequest): GetTicketTemplateSchemaResponse {
  var runtime = new Util.RuntimeOptions{};
  return getTicketTemplateSchemaWithOptions(request, runtime);
}

model GetUserTokenRequest {
  appKey?: string(name='AppKey'),
  instanceId?: string(name='InstanceId'),
  nick?: string(name='Nick'),
  userId?: string(name='UserId'),
}

model GetUserTokenResponseBody = {
  code?: string(name='Code'),
  data?: {
    expires?: long(name='Expires'),
    token?: string(name='Token'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GetUserTokenResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GetUserTokenResponseBody(name='body'),
}

async function getUserTokenWithOptions(request: GetUserTokenRequest, runtime: Util.RuntimeOptions): GetUserTokenResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.appKey)) {
    body['AppKey'] = request.appKey;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.nick)) {
    body['Nick'] = request.nick;
  }
  if (!Util.isUnset(request.userId)) {
    body['UserId'] = request.userId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GetUserToken',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function getUserToken(request: GetUserTokenRequest): GetUserTokenResponse {
  var runtime = new Util.RuntimeOptions{};
  return getUserTokenWithOptions(request, runtime);
}

model GrantRolesRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  operator?: string(name='Operator'),
  roleId?: [ long ](name='RoleId'),
}

model GrantRolesResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model GrantRolesResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: GrantRolesResponseBody(name='body'),
}

async function grantRolesWithOptions(request: GrantRolesRequest, runtime: Util.RuntimeOptions): GrantRolesResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operator)) {
    body['Operator'] = request.operator;
  }
  if (!Util.isUnset(request.roleId)) {
    body['RoleId'] = request.roleId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'GrantRoles',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function grantRoles(request: GrantRolesRequest): GrantRolesResponse {
  var runtime = new Util.RuntimeOptions{};
  return grantRolesWithOptions(request, runtime);
}

model HangUpAgentMonitorRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  callerParentId?: long(name='CallerParentId'),
  callerType?: string(name='CallerType'),
  callerUid?: long(name='CallerUid'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
  requestId?: string(name='RequestId'),
  stsTokenCallerUid?: long(name='StsTokenCallerUid'),
}

model HangUpAgentMonitorResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model HangUpAgentMonitorResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: HangUpAgentMonitorResponseBody(name='body'),
}

async function hangUpAgentMonitorWithOptions(request: HangUpAgentMonitorRequest, runtime: Util.RuntimeOptions): HangUpAgentMonitorResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'HangUpAgentMonitor',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function hangUpAgentMonitor(request: HangUpAgentMonitorRequest): HangUpAgentMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return hangUpAgentMonitorWithOptions(request, runtime);
}

model HangupCallRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
}

model HangupCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model HangupCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: HangupCallResponseBody(name='body'),
}

async function hangupCallWithOptions(request: HangupCallRequest, runtime: Util.RuntimeOptions): HangupCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'HangupCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function hangupCall(request: HangupCallRequest): HangupCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return hangupCallWithOptions(request, runtime);
}

model HangupThirdCallRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
}

model HangupThirdCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model HangupThirdCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: HangupThirdCallResponseBody(name='body'),
}

async function hangupThirdCallWithOptions(request: HangupThirdCallRequest, runtime: Util.RuntimeOptions): HangupThirdCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'HangupThirdCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function hangupThirdCall(request: HangupThirdCallRequest): HangupThirdCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return hangupThirdCallWithOptions(request, runtime);
}

model HoldCallRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
}

model HoldCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model HoldCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: HoldCallResponseBody(name='body'),
}

async function holdCallWithOptions(request: HoldCallRequest, runtime: Util.RuntimeOptions): HoldCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'HoldCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function holdCall(request: HoldCallRequest): HoldCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return holdCallWithOptions(request, runtime);
}

model JoinThirdCallRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  holdConnectionId?: string(name='HoldConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
}

model JoinThirdCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model JoinThirdCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: JoinThirdCallResponseBody(name='body'),
}

async function joinThirdCallWithOptions(request: JoinThirdCallRequest, runtime: Util.RuntimeOptions): JoinThirdCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.holdConnectionId)) {
    body['HoldConnectionId'] = request.holdConnectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'JoinThirdCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function joinThirdCall(request: JoinThirdCallRequest): JoinThirdCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return joinThirdCallWithOptions(request, runtime);
}

model ListAgentBySkillGroupIdRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  skillGroupId?: long(name='SkillGroupId'),
}

model ListAgentBySkillGroupIdResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      accountName?: string(name='AccountName'),
      agentId?: long(name='AgentId'),
      displayName?: string(name='DisplayName'),
      status?: int32(name='Status'),
      tenantId?: long(name='TenantId'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListAgentBySkillGroupIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListAgentBySkillGroupIdResponseBody(name='body'),
}

async function listAgentBySkillGroupIdWithOptions(request: ListAgentBySkillGroupIdRequest, runtime: Util.RuntimeOptions): ListAgentBySkillGroupIdResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListAgentBySkillGroupId',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listAgentBySkillGroupId(request: ListAgentBySkillGroupIdRequest): ListAgentBySkillGroupIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAgentBySkillGroupIdWithOptions(request, runtime);
}

model ListAllHotLineSkillGroupsRequest {
  accountName?: string(name='AccountName'),
  instanceId?: string(name='InstanceId'),
}

model ListAllHotLineSkillGroupsResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      depGroup?: {
        depGroupId?: long(name='DepGroupId'),
        depGroupName?: string(name='DepGroupName'),
      }(name='DepGroup'),
      skillGroupAgents?: [ 
        {
          agents?: [ 
            {
              accountName?: string(name='AccountName'),
              acid?: string(name='Acid'),
              agentId?: long(name='AgentId'),
              connId?: string(name='ConnId'),
              customerPhone?: string(name='CustomerPhone'),
              displayName?: string(name='DisplayName'),
              jobId?: string(name='JobId'),
              status?: long(name='Status'),
            }
          ](name='Agents'),
          skillGroup?: {
            displayName?: string(name='DisplayName'),
            skillGroupId?: long(name='SkillGroupId'),
          }(name='SkillGroup'),
        }
      ](name='SkillGroupAgents'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListAllHotLineSkillGroupsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListAllHotLineSkillGroupsResponseBody(name='body'),
}

async function listAllHotLineSkillGroupsWithOptions(request: ListAllHotLineSkillGroupsRequest, runtime: Util.RuntimeOptions): ListAllHotLineSkillGroupsResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListAllHotLineSkillGroups',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listAllHotLineSkillGroups(request: ListAllHotLineSkillGroupsRequest): ListAllHotLineSkillGroupsResponse {
  var runtime = new Util.RuntimeOptions{};
  return listAllHotLineSkillGroupsWithOptions(request, runtime);
}

model ListHotlineRecordRequest {
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model ListHotlineRecordResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      callId?: string(name='CallId'),
      connectionId?: string(name='ConnectionId'),
      endTime?: boolean(name='EndTime'),
      startTime?: boolean(name='StartTime'),
      url?: string(name='Url'),
    }
  ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListHotlineRecordResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListHotlineRecordResponseBody(name='body'),
}

async function listHotlineRecordWithOptions(request: ListHotlineRecordRequest, runtime: Util.RuntimeOptions): ListHotlineRecordResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListHotlineRecord',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listHotlineRecord(request: ListHotlineRecordRequest): ListHotlineRecordResponse {
  var runtime = new Util.RuntimeOptions{};
  return listHotlineRecordWithOptions(request, runtime);
}

model ListOutboundPhoneNumberRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model ListOutboundPhoneNumberResponseBody = {
  code?: string(name='Code'),
  data?: [ string ](name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListOutboundPhoneNumberResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListOutboundPhoneNumberResponseBody(name='body'),
}

async function listOutboundPhoneNumberWithOptions(request: ListOutboundPhoneNumberRequest, runtime: Util.RuntimeOptions): ListOutboundPhoneNumberResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListOutboundPhoneNumber',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listOutboundPhoneNumber(request: ListOutboundPhoneNumberRequest): ListOutboundPhoneNumberResponse {
  var runtime = new Util.RuntimeOptions{};
  return listOutboundPhoneNumberWithOptions(request, runtime);
}

model ListSkillGroupRequest {
  channelType?: int32(name='ChannelType'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model ListSkillGroupResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      channelType?: int32(name='ChannelType'),
      description?: string(name='Description'),
      displayName?: string(name='DisplayName'),
      name?: string(name='Name'),
      skillGroupId?: long(name='SkillGroupId'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model ListSkillGroupResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: ListSkillGroupResponseBody(name='body'),
}

async function listSkillGroupWithOptions(request: ListSkillGroupRequest, runtime: Util.RuntimeOptions): ListSkillGroupResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'ListSkillGroup',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function listSkillGroup(request: ListSkillGroupRequest): ListSkillGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return listSkillGroupWithOptions(request, runtime);
}

model LogOptimizationRequest {
  acid?: string(name='Acid'),
  data?: string(name='Data'),
  phoneNum?: string(name='PhoneNum'),
}

model LogOptimizationResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model LogOptimizationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: LogOptimizationResponseBody(name='body'),
}

async function logOptimizationWithOptions(request: LogOptimizationRequest, runtime: Util.RuntimeOptions): LogOptimizationResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.acid)) {
    query['Acid'] = request.acid;
  }
  if (!Util.isUnset(request.data)) {
    query['Data'] = request.data;
  }
  if (!Util.isUnset(request.phoneNum)) {
    query['PhoneNum'] = request.phoneNum;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'LogOptimization',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function logOptimization(request: LogOptimizationRequest): LogOptimizationResponse {
  var runtime = new Util.RuntimeOptions{};
  return logOptimizationWithOptions(request, runtime);
}

model QueryAppResDiffRequest {
  appTaskId?: string(name='AppTaskId'),
  diffKeyword?: string(name='DiffKeyword'),
  index?: int32(name='Index'),
  keyword?: string(name='Keyword'),
  resCode?: string(name='ResCode'),
  resName?: string(name='ResName'),
  resSubType?: string(name='ResSubType'),
  resType?: string(name='ResType'),
  size?: int32(name='Size'),
}

model QueryAppResDiffResponseBody = {
  code?: string(name='Code'),
  data?: {
    data?: [ 
      {
        baseFilteredValue?: string(name='BaseFilteredValue'),
        baseValue?: string(name='BaseValue'),
        filteredValue?: string(name='FilteredValue'),
        id?: string(name='Id'),
        res?: DAppRes(name='Res'),
        row?: [ 
          {
            key?: string(name='Key'),
            value?: string(name='Value'),
          }
        ](name='Row'),
        type?: DPair(name='Type'),
        value?: string(name='Value'),
        status?: DPair(name='status'),
      }
    ](name='Data'),
    head?: [ 
      {
        key?: string(name='Key'),
        title?: string(name='Title'),
      }
    ](name='Head'),
    resCount?: DAppResCount(name='ResCount'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalCount?: long(name='TotalCount'),
}

model QueryAppResDiffResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryAppResDiffResponseBody(name='body'),
}

async function queryAppResDiffWithOptions(request: QueryAppResDiffRequest, runtime: Util.RuntimeOptions): QueryAppResDiffResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryAppResDiff',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryAppResDiff(request: QueryAppResDiffRequest): QueryAppResDiffResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryAppResDiffWithOptions(request, runtime);
}

model QueryAppResValueRequest {
  appTaskId?: string(name='AppTaskId'),
  index?: int32(name='Index'),
  keyword?: string(name='Keyword'),
  resCode?: string(name='ResCode'),
  resName?: string(name='ResName'),
  resSubType?: string(name='ResSubType'),
  resType?: string(name='ResType'),
  size?: int32(name='Size'),
  valueKeyword?: string(name='ValueKeyword'),
}

model QueryAppResValueResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      id?: string(name='Id'),
      res?: DAppRes(name='Res'),
      value?: string(name='Value'),
    }
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalCount?: long(name='TotalCount'),
}

model QueryAppResValueResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryAppResValueResponseBody(name='body'),
}

async function queryAppResValueWithOptions(request: QueryAppResValueRequest, runtime: Util.RuntimeOptions): QueryAppResValueResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryAppResValue',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryAppResValue(request: QueryAppResValueRequest): QueryAppResValueResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryAppResValueWithOptions(request, runtime);
}

model QueryDeploymentArchiveRequest {
  deploymentCode?: string(name='DeploymentCode'),
  envType?: int32(name='EnvType'),
  index?: int32(name='Index'),
  size?: int32(name='Size'),
}

model QueryDeploymentArchiveResponseBody = {
  code?: string(name='Code'),
  data?: [
    DDeploymentArchive
  ](name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalCount?: long(name='TotalCount'),
}

model QueryDeploymentArchiveResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryDeploymentArchiveResponseBody(name='body'),
}

async function queryDeploymentArchiveWithOptions(request: QueryDeploymentArchiveRequest, runtime: Util.RuntimeOptions): QueryDeploymentArchiveResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryDeploymentArchive',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryDeploymentArchive(request: QueryDeploymentArchiveRequest): QueryDeploymentArchiveResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryDeploymentArchiveWithOptions(request, runtime);
}

model QueryHotlineDashboardRequest {
  currentPageNum?: int32(name='CurrentPageNum'),
  departmentIdList?: [ long ](name='DepartmentIdList'),
  endDate?: long(name='EndDate'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  servicerIdList?: [ long ](name='ServicerIdList'),
  sortFieldList?: [ string ](name='SortFieldList'),
  startDate?: long(name='StartDate'),
}

model QueryHotlineDashboardShrinkRequest {
  currentPageNum?: int32(name='CurrentPageNum'),
  departmentIdListShrink?: string(name='DepartmentIdList'),
  endDate?: long(name='EndDate'),
  instanceId?: string(name='InstanceId'),
  pageSize?: int32(name='PageSize'),
  servicerIdListShrink?: string(name='ServicerIdList'),
  sortFieldListShrink?: string(name='SortFieldList'),
  startDate?: long(name='StartDate'),
}

model QueryHotlineDashboardResponseBody = {
  code?: string(name='Code'),
  data?: {
    results?: [ 
      {
        dateId?: string(name='DateId'),
        departmentId?: long(name='DepartmentId'),
        departmentName?: string(name='DepartmentName'),
        effectiveInCalls?: int32(name='EffectiveInCalls'),
        effectiveInServiceNotes?: int32(name='EffectiveInServiceNotes'),
        effectiveOutCalls?: int32(name='EffectiveOutCalls'),
        effectiveOutServiceNotes?: int32(name='EffectiveOutServiceNotes'),
        servicerId?: long(name='ServicerId'),
        servicerRealName?: string(name='ServicerRealName'),
        servicerShowName?: string(name='ServicerShowName'),
      }
    ](name='Results'),
    total?: int32(name='Total'),
  }(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryHotlineDashboardResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryHotlineDashboardResponseBody(name='body'),
}

async function queryHotlineDashboardWithOptions(tmpReq: QueryHotlineDashboardRequest, runtime: Util.RuntimeOptions): QueryHotlineDashboardResponse {
  Util.validateModel(tmpReq);
  var request = new QueryHotlineDashboardShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.departmentIdList)) {
    request.departmentIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.departmentIdList, 'DepartmentIdList', 'json');
  }
  if (!Util.isUnset(tmpReq.servicerIdList)) {
    request.servicerIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.servicerIdList, 'ServicerIdList', 'json');
  }
  if (!Util.isUnset(tmpReq.sortFieldList)) {
    request.sortFieldListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.sortFieldList, 'SortFieldList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.currentPageNum)) {
    query['CurrentPageNum'] = request.currentPageNum;
  }
  if (!Util.isUnset(request.departmentIdListShrink)) {
    query['DepartmentIdList'] = request.departmentIdListShrink;
  }
  if (!Util.isUnset(request.endDate)) {
    query['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.servicerIdListShrink)) {
    query['ServicerIdList'] = request.servicerIdListShrink;
  }
  if (!Util.isUnset(request.sortFieldListShrink)) {
    query['SortFieldList'] = request.sortFieldListShrink;
  }
  if (!Util.isUnset(request.startDate)) {
    query['StartDate'] = request.startDate;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryHotlineDashboard',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryHotlineDashboard(request: QueryHotlineDashboardRequest): QueryHotlineDashboardResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryHotlineDashboardWithOptions(request, runtime);
}

model QueryHotlineSessionRequest {
  acid?: string(name='Acid'),
  callResult?: string(name='CallResult'),
  callType?: int32(name='CallType'),
  calledNumber?: string(name='CalledNumber'),
  callingNumber?: string(name='CallingNumber'),
  groupId?: long(name='GroupId'),
  groupName?: string(name='GroupName'),
  instanceId?: string(name='InstanceId'),
  memberId?: string(name='MemberId'),
  memberName?: string(name='MemberName'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  params?: string(name='Params'),
  queryEndTime?: long(name='QueryEndTime'),
  queryStartTime?: long(name='QueryStartTime'),
  requestId?: string(name='RequestId'),
  servicerId?: string(name='ServicerId'),
  servicerName?: string(name='ServicerName'),
}

model QueryHotlineSessionResponseBody = {
  code?: string(name='Code'),
  data?: {
    callDetailRecord?: [ 
      {
        acid?: string(name='Acid'),
        callContinueTime?: int32(name='CallContinueTime'),
        callResult?: string(name='CallResult'),
        callType?: int32(name='CallType'),
        calledNumber?: string(name='CalledNumber'),
        callingNumber?: string(name='CallingNumber'),
        createTime?: string(name='CreateTime'),
        evaluationLevel?: int32(name='EvaluationLevel'),
        evaluationScore?: int32(name='EvaluationScore'),
        groupId?: long(name='GroupId'),
        groupName?: string(name='GroupName'),
        hangUpRole?: string(name='HangUpRole'),
        hangUpTime?: string(name='HangUpTime'),
        inQueueTime?: string(name='InQueueTime'),
        memberId?: string(name='MemberId'),
        memberName?: string(name='MemberName'),
        outQueueTime?: string(name='OutQueueTime'),
        pickUpTime?: string(name='PickUpTime'),
        queueUpContinueTime?: int32(name='QueueUpContinueTime'),
        ringContinueTime?: int32(name='RingContinueTime'),
        ringEndTime?: string(name='RingEndTime'),
        ringStartTime?: string(name='RingStartTime'),
        servicerId?: string(name='ServicerId'),
        servicerName?: string(name='ServicerName'),
      }
    ](name='CallDetailRecord'),
    pageNumber?: int32(name='PageNumber'),
    pageSize?: int32(name='PageSize'),
    totalCount?: int32(name='TotalCount'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryHotlineSessionResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryHotlineSessionResponseBody(name='body'),
}

async function queryHotlineSessionWithOptions(request: QueryHotlineSessionRequest, runtime: Util.RuntimeOptions): QueryHotlineSessionResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.acid)) {
    query['Acid'] = request.acid;
  }
  if (!Util.isUnset(request.callResult)) {
    query['CallResult'] = request.callResult;
  }
  if (!Util.isUnset(request.callType)) {
    query['CallType'] = request.callType;
  }
  if (!Util.isUnset(request.calledNumber)) {
    query['CalledNumber'] = request.calledNumber;
  }
  if (!Util.isUnset(request.callingNumber)) {
    query['CallingNumber'] = request.callingNumber;
  }
  if (!Util.isUnset(request.groupId)) {
    query['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.groupName)) {
    query['GroupName'] = request.groupName;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.memberId)) {
    query['MemberId'] = request.memberId;
  }
  if (!Util.isUnset(request.memberName)) {
    query['MemberName'] = request.memberName;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.params)) {
    query['Params'] = request.params;
  }
  if (!Util.isUnset(request.queryEndTime)) {
    query['QueryEndTime'] = request.queryEndTime;
  }
  if (!Util.isUnset(request.queryStartTime)) {
    query['QueryStartTime'] = request.queryStartTime;
  }
  if (!Util.isUnset(request.requestId)) {
    query['RequestId'] = request.requestId;
  }
  if (!Util.isUnset(request.servicerId)) {
    query['ServicerId'] = request.servicerId;
  }
  if (!Util.isUnset(request.servicerName)) {
    query['ServicerName'] = request.servicerName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryHotlineSession',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryHotlineSession(request: QueryHotlineSessionRequest): QueryHotlineSessionResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryHotlineSessionWithOptions(request, runtime);
}

model QueryRelationTicketsRequest {
  caseId?: long(name='CaseId'),
  caseType?: int32(name='CaseType'),
  channelId?: string(name='ChannelId'),
  channelType?: int32(name='ChannelType'),
  currentPage?: int32(name='CurrentPage'),
  dealId?: long(name='DealId'),
  endCaseGmtCreate?: long(name='EndCaseGmtCreate'),
  extra?: map[string]any(name='Extra'),
  instanceId?: string(name='InstanceId'),
  memberId?: long(name='MemberId'),
  pageSize?: int32(name='PageSize'),
  srType?: int32(name='SrType'),
  startCaseGmtCreate?: long(name='StartCaseGmtCreate'),
  taskStatus?: int32(name='TaskStatus'),
  touchId?: long(name='TouchId'),
}

model QueryRelationTicketsResponseBody = {
  cnePageSize?: int32(name='CnePageSize'),
  code?: string(name='Code'),
  currentPage?: int32(name='CurrentPage'),
  data?: [ 
    {
      assignTime?: long(name='AssignTime'),
      buId?: long(name='BuId'),
      caseBuId?: long(name='CaseBuId'),
      caseDepartmentId?: long(name='CaseDepartmentId'),
      caseGmtCreate?: long(name='CaseGmtCreate'),
      caseId?: long(name='CaseId'),
      caseStatus?: int32(name='CaseStatus'),
      caseType?: int32(name='CaseType'),
      channelId?: string(name='ChannelId'),
      channelType?: int32(name='ChannelType'),
      creatorId?: long(name='CreatorId'),
      deadLine?: long(name='DeadLine'),
      dealId?: long(name='DealId'),
      dealTime?: long(name='DealTime'),
      departmentId?: long(name='DepartmentId'),
      extAttrs?: map[string]any(name='ExtAttrs'),
      formId?: long(name='FormId'),
      fromInfo?: string(name='FromInfo'),
      gaseGmtModified?: long(name='GaseGmtModified'),
      gmtCreate?: long(name='GmtCreate'),
      gmtModified?: long(name='GmtModified'),
      groupId?: long(name='GroupId'),
      groupName?: string(name='GroupName'),
      memberId?: long(name='MemberId'),
      memberName?: string(name='MemberName'),
      owner?: long(name='Owner'),
      ownerName?: string(name='OwnerName'),
      parentId?: long(name='ParentId'),
      priority?: int32(name='Priority'),
      questionId?: string(name='QuestionId'),
      questionInfo?: string(name='QuestionInfo'),
      refCaseId?: long(name='RefCaseId'),
      relationCase?: [ 
        {
          assignTime?: long(name='AssignTime'),
          buId?: long(name='BuId'),
          caseBuId?: long(name='CaseBuId'),
          caseDepartmentId?: long(name='CaseDepartmentId'),
          caseGmtCreate?: long(name='CaseGmtCreate'),
          caseGmtModified?: long(name='CaseGmtModified'),
          caseId?: long(name='CaseId'),
          caseStatus?: int32(name='CaseStatus'),
          caseType?: int32(name='CaseType'),
          channelId?: string(name='ChannelId'),
          channelType?: int32(name='ChannelType'),
          creatorId?: long(name='CreatorId'),
          deadLine?: long(name='DeadLine'),
          dealId?: long(name='DealId'),
          dealTime?: long(name='DealTime'),
          departmentId?: long(name='DepartmentId'),
          extAttrs?: map[string]any(name='ExtAttrs'),
          formId?: long(name='FormId'),
          fromInfo?: string(name='FromInfo'),
          gmtCreate?: long(name='GmtCreate'),
          gmtModified?: long(name='GmtModified'),
          groupId?: long(name='GroupId'),
          groupName?: string(name='GroupName'),
          memberId?: long(name='MemberId'),
          memberName?: string(name='MemberName'),
          owner?: long(name='Owner'),
          ownerName?: string(name='OwnerName'),
          parentId?: long(name='ParentId'),
          priority?: int32(name='Priority'),
          questionId?: string(name='QuestionId'),
          questionInfoQuestionInfo?: string(name='QuestionInfoQuestionInfo'),
          refCaseId?: long(name='RefCaseId'),
          serviceType?: int32(name='ServiceType'),
          taskId?: long(name='TaskId'),
          taskStatus?: int32(name='TaskStatus'),
          taskType?: int32(name='TaskType'),
          templateId?: long(name='TemplateId'),
          title?: string(name='Title'),
          userServiceId?: long(name='UserServiceId'),
        }
      ](name='RelationCase'),
      serviceType?: int32(name='ServiceType'),
      srType?: long(name='SrType'),
      taskId?: long(name='TaskId'),
      taskStatus?: int32(name='TaskStatus'),
      taskType?: int32(name='TaskType'),
      templateId?: long(name='TemplateId'),
      title?: string(name='Title'),
      userServiceId?: long(name='UserServiceId'),
    }
  ](name='Data'),
  firstResult?: int32(name='FirstResult'),
  message?: string(name='Message'),
  nextPage?: int32(name='NextPage'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalPage?: int32(name='TotalPage'),
  totalResults?: int32(name='TotalResults'),
}

model QueryRelationTicketsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryRelationTicketsResponseBody(name='body'),
}

async function queryRelationTicketsWithOptions(request: QueryRelationTicketsRequest, runtime: Util.RuntimeOptions): QueryRelationTicketsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.caseId)) {
    body['CaseId'] = request.caseId;
  }
  if (!Util.isUnset(request.caseType)) {
    body['CaseType'] = request.caseType;
  }
  if (!Util.isUnset(request.channelId)) {
    body['ChannelId'] = request.channelId;
  }
  if (!Util.isUnset(request.channelType)) {
    body['ChannelType'] = request.channelType;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.dealId)) {
    body['DealId'] = request.dealId;
  }
  if (!Util.isUnset(request.endCaseGmtCreate)) {
    body['EndCaseGmtCreate'] = request.endCaseGmtCreate;
  }
  var bodyFlat : map[string]any = {};
  if (!Util.isUnset(request.extra)) {
    bodyFlat['Extra'] = request.extra;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.memberId)) {
    body['MemberId'] = request.memberId;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.srType)) {
    body['SrType'] = request.srType;
  }
  if (!Util.isUnset(request.startCaseGmtCreate)) {
    body['StartCaseGmtCreate'] = request.startCaseGmtCreate;
  }
  if (!Util.isUnset(request.taskStatus)) {
    body['TaskStatus'] = request.taskStatus;
  }
  if (!Util.isUnset(request.touchId)) {
    body['TouchId'] = request.touchId;
  }
  body = {
    ...body,
    ...OpenApiUtil.query(bodyFlat),
  };

  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryRelationTickets',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryRelationTickets(request: QueryRelationTicketsRequest): QueryRelationTicketsResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryRelationTicketsWithOptions(request, runtime);
}

model QueryRingDetailListRequest {
  callOutStatus?: string(name='CallOutStatus'),
  endDate?: long(name='EndDate'),
  extra?: string(name='Extra'),
  fromPhoneNumList?: map[string]any(name='FromPhoneNumList'),
  instanceId?: string(name='InstanceId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  toPhoneNumList?: map[string]any(name='ToPhoneNumList'),
}

model QueryRingDetailListShrinkRequest {
  callOutStatus?: string(name='CallOutStatus'),
  endDate?: long(name='EndDate'),
  extra?: string(name='Extra'),
  fromPhoneNumListShrink?: string(name='FromPhoneNumList'),
  instanceId?: string(name='InstanceId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  startDate?: long(name='StartDate'),
  toPhoneNumListShrink?: string(name='ToPhoneNumList'),
}

model QueryRingDetailListResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryRingDetailListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryRingDetailListResponseBody(name='body'),
}

async function queryRingDetailListWithOptions(tmpReq: QueryRingDetailListRequest, runtime: Util.RuntimeOptions): QueryRingDetailListResponse {
  Util.validateModel(tmpReq);
  var request = new QueryRingDetailListShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.fromPhoneNumList)) {
    request.fromPhoneNumListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.fromPhoneNumList, 'FromPhoneNumList', 'json');
  }
  if (!Util.isUnset(tmpReq.toPhoneNumList)) {
    request.toPhoneNumListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.toPhoneNumList, 'ToPhoneNumList', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.callOutStatus)) {
    body['CallOutStatus'] = request.callOutStatus;
  }
  if (!Util.isUnset(request.endDate)) {
    body['EndDate'] = request.endDate;
  }
  if (!Util.isUnset(request.extra)) {
    body['Extra'] = request.extra;
  }
  if (!Util.isUnset(request.fromPhoneNumListShrink)) {
    body['FromPhoneNumList'] = request.fromPhoneNumListShrink;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.pageNo)) {
    body['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.startDate)) {
    body['StartDate'] = request.startDate;
  }
  if (!Util.isUnset(request.toPhoneNumListShrink)) {
    body['ToPhoneNumList'] = request.toPhoneNumListShrink;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryRingDetailList',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryRingDetailList(request: QueryRingDetailListRequest): QueryRingDetailListResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryRingDetailListWithOptions(request, runtime);
}

model QueryServiceConfigRequest {
  instanceId?: string(name='InstanceId'),
  parameters?: string(name='Parameters'),
  viewCode?: string(name='ViewCode'),
}

model QueryServiceConfigResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryServiceConfigResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryServiceConfigResponseBody(name='body'),
}

async function queryServiceConfigWithOptions(request: QueryServiceConfigRequest, runtime: Util.RuntimeOptions): QueryServiceConfigResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryServiceConfig',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryServiceConfig(request: QueryServiceConfigRequest): QueryServiceConfigResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryServiceConfigWithOptions(request, runtime);
}

model QueryServicerByDepartmentAndMixNameRequest {
  currentPageNum?: long(name='CurrentPageNum'),
  departmentIdList?: [ long ](name='DepartmentIdList'),
  instanceId?: string(name='InstanceId'),
  keyWord?: string(name='KeyWord'),
  pageSize?: long(name='PageSize'),
}

model QueryServicerByDepartmentAndMixNameShrinkRequest {
  currentPageNum?: long(name='CurrentPageNum'),
  departmentIdListShrink?: string(name='DepartmentIdList'),
  instanceId?: string(name='InstanceId'),
  keyWord?: string(name='KeyWord'),
  pageSize?: long(name='PageSize'),
}

model QueryServicerByDepartmentAndMixNameResponseBody = {
  code?: string(name='Code'),
  data?: {
    results?: [ 
      {
        accountName?: string(name='AccountName'),
        departmentId?: long(name='DepartmentId'),
        departmentName?: string(name='DepartmentName'),
        realName?: string(name='RealName'),
        servicerId?: long(name='ServicerId'),
        showName?: string(name='ShowName'),
        userStatus?: int32(name='UserStatus'),
      }
    ](name='Results'),
    total?: int32(name='Total'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryServicerByDepartmentAndMixNameResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryServicerByDepartmentAndMixNameResponseBody(name='body'),
}

async function queryServicerByDepartmentAndMixNameWithOptions(tmpReq: QueryServicerByDepartmentAndMixNameRequest, runtime: Util.RuntimeOptions): QueryServicerByDepartmentAndMixNameResponse {
  Util.validateModel(tmpReq);
  var request = new QueryServicerByDepartmentAndMixNameShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.departmentIdList)) {
    request.departmentIdListShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.departmentIdList, 'DepartmentIdList', 'json');
  }
  var query = {};
  if (!Util.isUnset(request.currentPageNum)) {
    query['CurrentPageNum'] = request.currentPageNum;
  }
  if (!Util.isUnset(request.departmentIdListShrink)) {
    query['DepartmentIdList'] = request.departmentIdListShrink;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.keyWord)) {
    query['KeyWord'] = request.keyWord;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryServicerByDepartmentAndMixName',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryServicerByDepartmentAndMixName(request: QueryServicerByDepartmentAndMixNameRequest): QueryServicerByDepartmentAndMixNameResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryServicerByDepartmentAndMixNameWithOptions(request, runtime);
}

model QueryServicerByIdRequest {
  instanceId?: string(name='InstanceId'),
  servicerId?: long(name='ServicerId'),
}

model QueryServicerByIdResponseBody = {
  code?: string(name='Code'),
  data?: {
    accountName?: string(name='AccountName'),
    departmentId?: long(name='DepartmentId'),
    realName?: string(name='RealName'),
    servicerId?: long(name='ServicerId'),
    showName?: string(name='ShowName'),
    userStatus?: int32(name='UserStatus'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryServicerByIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryServicerByIdResponseBody(name='body'),
}

async function queryServicerByIdWithOptions(request: QueryServicerByIdRequest, runtime: Util.RuntimeOptions): QueryServicerByIdResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.servicerId)) {
    query['ServicerId'] = request.servicerId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryServicerById',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryServicerById(request: QueryServicerByIdRequest): QueryServicerByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryServicerByIdWithOptions(request, runtime);
}

model QuerySkillGroupsRequest {
  clientToken?: string(name='ClientToken'),
  groupId?: long(name='GroupId'),
  groupName?: string(name='GroupName'),
  groupType?: int32(name='GroupType'),
  instanceId?: string(name='InstanceId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
}

model QuerySkillGroupsResponseBody = {
  currentPage?: int32(name='CurrentPage'),
  data?: [ 
    {
      channelType?: int32(name='ChannelType'),
      description?: string(name='Description'),
      displayName?: string(name='DisplayName'),
      skillGroupId?: long(name='SkillGroupId'),
      skillGroupName?: string(name='SkillGroupName'),
    }
  ](name='Data'),
  onePageSize?: int32(name='OnePageSize'),
  requestId?: string(name='RequestId'),
  totalPage?: int32(name='TotalPage'),
  totalResults?: int32(name='TotalResults'),
}

model QuerySkillGroupsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QuerySkillGroupsResponseBody(name='body'),
}

async function querySkillGroupsWithOptions(request: QuerySkillGroupsRequest, runtime: Util.RuntimeOptions): QuerySkillGroupsResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.groupId)) {
    query['GroupId'] = request.groupId;
  }
  if (!Util.isUnset(request.groupName)) {
    query['GroupName'] = request.groupName;
  }
  if (!Util.isUnset(request.groupType)) {
    query['GroupType'] = request.groupType;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.pageNo)) {
    query['PageNo'] = request.pageNo;
  }
  if (!Util.isUnset(request.pageSize)) {
    query['PageSize'] = request.pageSize;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QuerySkillGroups',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function querySkillGroups(request: QuerySkillGroupsRequest): QuerySkillGroupsResponse {
  var runtime = new Util.RuntimeOptions{};
  return querySkillGroupsWithOptions(request, runtime);
}

model QueryTicketActionsRequest {
  actionCodeList?: [ int32 ](name='ActionCodeList'),
  instanceId?: string(name='InstanceId'),
  ticketId?: string(name='TicketId'),
}

model QueryTicketActionsResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryTicketActionsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryTicketActionsResponseBody(name='body'),
}

async function queryTicketActionsWithOptions(request: QueryTicketActionsRequest, runtime: Util.RuntimeOptions): QueryTicketActionsResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.actionCodeList)) {
    body['ActionCodeList'] = request.actionCodeList;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.ticketId)) {
    body['TicketId'] = request.ticketId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryTicketActions',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryTicketActions(request: QueryTicketActionsRequest): QueryTicketActionsResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTicketActionsWithOptions(request, runtime);
}

model QueryTicketCountRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  operatorId?: long(name='OperatorId'),
}

model QueryTicketCountResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryTicketCountResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryTicketCountResponseBody(name='body'),
}

async function queryTicketCountWithOptions(request: QueryTicketCountRequest, runtime: Util.RuntimeOptions): QueryTicketCountResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operatorId)) {
    query['OperatorId'] = request.operatorId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'QueryTicketCount',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryTicketCount(request: QueryTicketCountRequest): QueryTicketCountResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTicketCountWithOptions(request, runtime);
}

model QueryTicketsRequest {
  accountName?: string(name='AccountName'),
  caseId?: long(name='CaseId'),
  caseStatus?: int32(name='CaseStatus'),
  caseType?: int32(name='CaseType'),
  channelId?: string(name='ChannelId'),
  channelType?: int32(name='ChannelType'),
  currentPage?: int32(name='CurrentPage'),
  dealId?: long(name='DealId'),
  endCaseGmtCreate?: long(name='EndCaseGmtCreate'),
  extra?: map[string]any(name='Extra'),
  instanceId?: string(name='InstanceId'),
  memberId?: long(name='MemberId'),
  pageSize?: int32(name='PageSize'),
  parentCaseId?: long(name='ParentCaseId'),
  srType?: long(name='SrType'),
  startCaseGmtCreate?: long(name='StartCaseGmtCreate'),
  taskStatus?: int32(name='TaskStatus'),
  touchId?: long(name='TouchId'),
}

model QueryTicketsShrinkRequest {
  accountName?: string(name='AccountName'),
  caseId?: long(name='CaseId'),
  caseStatus?: int32(name='CaseStatus'),
  caseType?: int32(name='CaseType'),
  channelId?: string(name='ChannelId'),
  channelType?: int32(name='ChannelType'),
  currentPage?: int32(name='CurrentPage'),
  dealId?: long(name='DealId'),
  endCaseGmtCreate?: long(name='EndCaseGmtCreate'),
  extraShrink?: string(name='Extra'),
  instanceId?: string(name='InstanceId'),
  memberId?: long(name='MemberId'),
  pageSize?: int32(name='PageSize'),
  parentCaseId?: long(name='ParentCaseId'),
  srType?: long(name='SrType'),
  startCaseGmtCreate?: long(name='StartCaseGmtCreate'),
  taskStatus?: int32(name='TaskStatus'),
  touchId?: long(name='TouchId'),
}

model QueryTicketsResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model QueryTicketsResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: QueryTicketsResponseBody(name='body'),
}

async function queryTicketsWithOptions(tmpReq: QueryTicketsRequest, runtime: Util.RuntimeOptions): QueryTicketsResponse {
  Util.validateModel(tmpReq);
  var request = new QueryTicketsShrinkRequest{};
  OpenApiUtil.convert(tmpReq, request);
  if (!Util.isUnset(tmpReq.extra)) {
    request.extraShrink = OpenApiUtil.arrayToStringWithSpecifiedStyle(tmpReq.extra, 'Extra', 'json');
  }
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.caseId)) {
    body['CaseId'] = request.caseId;
  }
  if (!Util.isUnset(request.caseStatus)) {
    body['CaseStatus'] = request.caseStatus;
  }
  if (!Util.isUnset(request.caseType)) {
    body['CaseType'] = request.caseType;
  }
  if (!Util.isUnset(request.channelId)) {
    body['ChannelId'] = request.channelId;
  }
  if (!Util.isUnset(request.channelType)) {
    body['ChannelType'] = request.channelType;
  }
  if (!Util.isUnset(request.currentPage)) {
    body['CurrentPage'] = request.currentPage;
  }
  if (!Util.isUnset(request.dealId)) {
    body['DealId'] = request.dealId;
  }
  if (!Util.isUnset(request.endCaseGmtCreate)) {
    body['EndCaseGmtCreate'] = request.endCaseGmtCreate;
  }
  if (!Util.isUnset(request.extraShrink)) {
    body['Extra'] = request.extraShrink;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.memberId)) {
    body['MemberId'] = request.memberId;
  }
  if (!Util.isUnset(request.pageSize)) {
    body['PageSize'] = request.pageSize;
  }
  if (!Util.isUnset(request.parentCaseId)) {
    body['ParentCaseId'] = request.parentCaseId;
  }
  if (!Util.isUnset(request.srType)) {
    body['SrType'] = request.srType;
  }
  if (!Util.isUnset(request.startCaseGmtCreate)) {
    body['StartCaseGmtCreate'] = request.startCaseGmtCreate;
  }
  if (!Util.isUnset(request.taskStatus)) {
    body['TaskStatus'] = request.taskStatus;
  }
  if (!Util.isUnset(request.touchId)) {
    body['TouchId'] = request.touchId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'QueryTickets',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function queryTickets(request: QueryTicketsRequest): QueryTicketsResponse {
  var runtime = new Util.RuntimeOptions{};
  return queryTicketsWithOptions(request, runtime);
}

model RemoveSkillGroupRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  skillGroupId?: string(name='SkillGroupId'),
}

model RemoveSkillGroupResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model RemoveSkillGroupResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: RemoveSkillGroupResponseBody(name='body'),
}

async function removeSkillGroupWithOptions(request: RemoveSkillGroupRequest, runtime: Util.RuntimeOptions): RemoveSkillGroupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.skillGroupId)) {
    body['SkillGroupId'] = request.skillGroupId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'RemoveSkillGroup',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function removeSkillGroup(request: RemoveSkillGroupRequest): RemoveSkillGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return removeSkillGroupWithOptions(request, runtime);
}

model SearchTicketByIdRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  statusCode?: int32(name='StatusCode'),
  ticketId?: long(name='TicketId'),
}

model SearchTicketByIdResponseBody = {
  code?: string(name='Code'),
  data?: {
    activities?: [ 
      {
        activityCode?: string(name='ActivityCode'),
        activityFormData?: string(name='ActivityFormData'),
      }
    ](name='Activities'),
    activityRecords?: [ 
      {
        actionCode?: string(name='ActionCode'),
        actionCodeDesc?: string(name='ActionCodeDesc'),
        gmtCreate?: long(name='GmtCreate'),
        memo?: string(name='Memo'),
        operator?: string(name='Operator'),
        operatorName?: string(name='OperatorName'),
      }
    ](name='ActivityRecords'),
    carbonCopy?: string(name='CarbonCopy'),
    caseStatus?: int32(name='CaseStatus'),
    categoryId?: long(name='CategoryId'),
    createTime?: long(name='CreateTime'),
    creatorId?: long(name='CreatorId'),
    creatorName?: string(name='CreatorName'),
    creatorType?: int32(name='CreatorType'),
    formData?: string(name='FormData'),
    fromInfo?: string(name='FromInfo'),
    memberId?: long(name='MemberId'),
    memberName?: string(name='MemberName'),
    modifiedTime?: long(name='ModifiedTime'),
    parentCaseId?: long(name='ParentCaseId'),
    priority?: int32(name='Priority'),
    serviceId?: long(name='ServiceId'),
    templateId?: long(name='TemplateId'),
    ticketId?: long(name='TicketId'),
    ticketName?: string(name='TicketName'),
  }(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SearchTicketByIdResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SearchTicketByIdResponseBody(name='body'),
}

async function searchTicketByIdWithOptions(request: SearchTicketByIdRequest, runtime: Util.RuntimeOptions): SearchTicketByIdResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SearchTicketById',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchTicketById(request: SearchTicketByIdRequest): SearchTicketByIdResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchTicketByIdWithOptions(request, runtime);
}

model SearchTicketByPhoneRequest {
  clientToken?: string(name='ClientToken'),
  endTime?: long(name='EndTime'),
  instanceId?: string(name='InstanceId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  phone?: string(name='Phone'),
  startTime?: long(name='StartTime'),
  templateId?: long(name='TemplateId'),
  ticketStatus?: string(name='TicketStatus'),
}

model SearchTicketByPhoneResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      carbonCopy?: string(name='CarbonCopy'),
      caseStatus?: int32(name='CaseStatus'),
      categoryId?: long(name='CategoryId'),
      createTime?: long(name='CreateTime'),
      creatorId?: long(name='CreatorId'),
      creatorName?: string(name='CreatorName'),
      creatorType?: int32(name='CreatorType'),
      formData?: string(name='FormData'),
      fromInfo?: string(name='FromInfo'),
      memberId?: long(name='MemberId'),
      memberName?: string(name='MemberName'),
      modifiedTime?: long(name='ModifiedTime'),
      priority?: int32(name='Priority'),
      serviceId?: long(name='ServiceId'),
      taskStatus?: string(name='TaskStatus'),
      templateId?: long(name='TemplateId'),
      ticketId?: long(name='TicketId'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  onePageSize?: int32(name='OnePageSize'),
  pageNo?: int32(name='PageNo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalPage?: int32(name='TotalPage'),
  totalResults?: int32(name='TotalResults'),
}

model SearchTicketByPhoneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SearchTicketByPhoneResponseBody(name='body'),
}

async function searchTicketByPhoneWithOptions(request: SearchTicketByPhoneRequest, runtime: Util.RuntimeOptions): SearchTicketByPhoneResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SearchTicketByPhone',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchTicketByPhone(request: SearchTicketByPhoneRequest): SearchTicketByPhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchTicketByPhoneWithOptions(request, runtime);
}

model SearchTicketListRequest {
  clientToken?: string(name='ClientToken'),
  endTime?: long(name='EndTime'),
  instanceId?: string(name='InstanceId'),
  operatorId?: long(name='OperatorId'),
  pageNo?: int32(name='PageNo'),
  pageSize?: int32(name='PageSize'),
  startTime?: long(name='StartTime'),
  ticketStatus?: string(name='TicketStatus'),
}

model SearchTicketListResponseBody = {
  code?: string(name='Code'),
  data?: [ 
    {
      carbonCopy?: string(name='CarbonCopy'),
      caseStatus?: int32(name='CaseStatus'),
      categoryId?: long(name='CategoryId'),
      createTime?: long(name='CreateTime'),
      creatorId?: long(name='CreatorId'),
      creatorName?: string(name='CreatorName'),
      creatorType?: int32(name='CreatorType'),
      formData?: string(name='FormData'),
      fromInfo?: string(name='FromInfo'),
      memberId?: long(name='MemberId'),
      memberName?: string(name='MemberName'),
      modifiedTime?: long(name='ModifiedTime'),
      priority?: int32(name='Priority'),
      serviceId?: long(name='ServiceId'),
      taskStatus?: string(name='TaskStatus'),
      templateId?: long(name='TemplateId'),
      ticketId?: long(name='TicketId'),
    }
  ](name='Data'),
  message?: string(name='Message'),
  onePageSize?: int32(name='OnePageSize'),
  pageNo?: int32(name='PageNo'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
  totalPage?: int32(name='TotalPage'),
  totalResults?: int32(name='TotalResults'),
}

model SearchTicketListResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SearchTicketListResponseBody(name='body'),
}

async function searchTicketListWithOptions(request: SearchTicketListRequest, runtime: Util.RuntimeOptions): SearchTicketListResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'SearchTicketList',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function searchTicketList(request: SearchTicketListRequest): SearchTicketListResponse {
  var runtime = new Util.RuntimeOptions{};
  return searchTicketListWithOptions(request, runtime);
}

model SendHotlineHeartBeatRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  token?: string(name='Token'),
}

model SendHotlineHeartBeatResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SendHotlineHeartBeatResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SendHotlineHeartBeatResponseBody(name='body'),
}

async function sendHotlineHeartBeatWithOptions(request: SendHotlineHeartBeatRequest, runtime: Util.RuntimeOptions): SendHotlineHeartBeatResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.token)) {
    body['Token'] = request.token;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SendHotlineHeartBeat',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendHotlineHeartBeat(request: SendHotlineHeartBeatRequest): SendHotlineHeartBeatResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendHotlineHeartBeatWithOptions(request, runtime);
}

model SendOutboundCommandRequest {
  accountName?: string(name='AccountName'),
  calledNumber?: string(name='CalledNumber'),
  callingNumber?: string(name='CallingNumber'),
  customerInfo?: string(name='CustomerInfo'),
  instanceId?: string(name='InstanceId'),
}

model SendOutboundCommandResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SendOutboundCommandResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SendOutboundCommandResponseBody(name='body'),
}

async function sendOutboundCommandWithOptions(request: SendOutboundCommandRequest, runtime: Util.RuntimeOptions): SendOutboundCommandResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.calledNumber)) {
    body['CalledNumber'] = request.calledNumber;
  }
  if (!Util.isUnset(request.callingNumber)) {
    body['CallingNumber'] = request.callingNumber;
  }
  if (!Util.isUnset(request.customerInfo)) {
    body['CustomerInfo'] = request.customerInfo;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SendOutboundCommand',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendOutboundCommand(request: SendOutboundCommandRequest): SendOutboundCommandResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendOutboundCommandWithOptions(request, runtime);
}

model SendVerificationCodeRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  phone?: string(name='Phone'),
}

model SendVerificationCodeResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SendVerificationCodeResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SendVerificationCodeResponseBody(name='body'),
}

async function sendVerificationCodeWithOptions(request: SendVerificationCodeRequest, runtime: Util.RuntimeOptions): SendVerificationCodeResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.phone)) {
    body['Phone'] = request.phone;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SendVerificationCode',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function sendVerificationCode(request: SendVerificationCodeRequest): SendVerificationCodeResponse {
  var runtime = new Util.RuntimeOptions{};
  return sendVerificationCodeWithOptions(request, runtime);
}

model StartAgentMonitorRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  callerParentId?: long(name='CallerParentId'),
  callerType?: string(name='CallerType'),
  callerUid?: long(name='CallerUid'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
  requestId?: string(name='RequestId'),
  stsTokenCallerUid?: long(name='StsTokenCallerUid'),
}

model StartAgentMonitorResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartAgentMonitorResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartAgentMonitorResponseBody(name='body'),
}

async function startAgentMonitorWithOptions(request: StartAgentMonitorRequest, runtime: Util.RuntimeOptions): StartAgentMonitorResponse {
  Util.validateModel(request);
  var query = OpenApiUtil.query(Util.toMap(request));
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'StartAgentMonitor',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'GET',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startAgentMonitor(request: StartAgentMonitorRequest): StartAgentMonitorResponse {
  var runtime = new Util.RuntimeOptions{};
  return startAgentMonitorWithOptions(request, runtime);
}

model StartCallRequest {
  accountName?: string(name='AccountName'),
  callee?: string(name='Callee'),
  caller?: string(name='Caller'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model StartCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartCallResponseBody(name='body'),
}

async function startCallWithOptions(request: StartCallRequest, runtime: Util.RuntimeOptions): StartCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callee)) {
    body['Callee'] = request.callee;
  }
  if (!Util.isUnset(request.caller)) {
    body['Caller'] = request.caller;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StartCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startCall(request: StartCallRequest): StartCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return startCallWithOptions(request, runtime);
}

model StartCallV2Request {
  accountName?: string(name='AccountName'),
  callee?: string(name='Callee'),
  caller?: string(name='Caller'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  jsonMsg?: string(name='JsonMsg'),
}

model StartCallV2ResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartCallV2Response = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartCallV2ResponseBody(name='body'),
}

async function startCallV2WithOptions(request: StartCallV2Request, runtime: Util.RuntimeOptions): StartCallV2Response {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callee)) {
    body['Callee'] = request.callee;
  }
  if (!Util.isUnset(request.caller)) {
    body['Caller'] = request.caller;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jsonMsg)) {
    body['JsonMsg'] = request.jsonMsg;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StartCallV2',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startCallV2(request: StartCallV2Request): StartCallV2Response {
  var runtime = new Util.RuntimeOptions{};
  return startCallV2WithOptions(request, runtime);
}

model StartChatWorkRequest {
  accountName?: string(name='AccountName'),
  instanceId?: string(name='InstanceId'),
}

model StartChatWorkResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: int32(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartChatWorkResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartChatWorkResponseBody(name='body'),
}

async function startChatWorkWithOptions(request: StartChatWorkRequest, runtime: Util.RuntimeOptions): StartChatWorkResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StartChatWork',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startChatWork(request: StartChatWorkRequest): StartChatWorkResponse {
  var runtime = new Util.RuntimeOptions{};
  return startChatWorkWithOptions(request, runtime);
}

model StartHotlineServiceRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model StartHotlineServiceResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartHotlineServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartHotlineServiceResponseBody(name='body'),
}

async function startHotlineServiceWithOptions(request: StartHotlineServiceRequest, runtime: Util.RuntimeOptions): StartHotlineServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StartHotlineService',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startHotlineService(request: StartHotlineServiceRequest): StartHotlineServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return startHotlineServiceWithOptions(request, runtime);
}

model StartHotlineWorkRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  skillGroups?: string(name='SkillGroups'),
  workChannel?: string(name='WorkChannel'),
}

model StartHotlineWorkResponseBody = {
  code?: string(name='Code'),
  data?: {
    accountName?: string(name='AccountName'),
    agentId?: long(name='AgentId'),
    agentStatusCode?: string(name='AgentStatusCode'),
    agentStatusDesc?: string(name='AgentStatusDesc'),
    agentToken?: string(name='AgentToken'),
    extAttr?: string(name='ExtAttr'),
    tenantId?: long(name='TenantId'),
    workChannel?: string(name='WorkChannel'),
  }(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model StartHotlineWorkResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: StartHotlineWorkResponseBody(name='body'),
}

async function startHotlineWorkWithOptions(request: StartHotlineWorkRequest, runtime: Util.RuntimeOptions): StartHotlineWorkResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.skillGroups)) {
    body['SkillGroups'] = request.skillGroups;
  }
  if (!Util.isUnset(request.workChannel)) {
    body['WorkChannel'] = request.workChannel;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'StartHotlineWork',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function startHotlineWork(request: StartHotlineWorkRequest): StartHotlineWorkResponse {
  var runtime = new Util.RuntimeOptions{};
  return startHotlineWorkWithOptions(request, runtime);
}

model SuspendHotlineServiceRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  type?: int32(name='Type'),
}

model SuspendHotlineServiceResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model SuspendHotlineServiceResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: SuspendHotlineServiceResponseBody(name='body'),
}

async function suspendHotlineServiceWithOptions(request: SuspendHotlineServiceRequest, runtime: Util.RuntimeOptions): SuspendHotlineServiceResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'SuspendHotlineService',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function suspendHotlineService(request: SuspendHotlineServiceRequest): SuspendHotlineServiceResponse {
  var runtime = new Util.RuntimeOptions{};
  return suspendHotlineServiceWithOptions(request, runtime);
}

model TransferCallToAgentRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  holdConnectionId?: string(name='HoldConnectionId'),
  instanceId?: string(name='InstanceId'),
  isSingleTransfer?: string(name='IsSingleTransfer'),
  jobId?: string(name='JobId'),
  targetAccountName?: string(name='TargetAccountName'),
  type?: int32(name='Type'),
}

model TransferCallToAgentResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model TransferCallToAgentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: TransferCallToAgentResponseBody(name='body'),
}

async function transferCallToAgentWithOptions(request: TransferCallToAgentRequest, runtime: Util.RuntimeOptions): TransferCallToAgentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.holdConnectionId)) {
    body['HoldConnectionId'] = request.holdConnectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.isSingleTransfer)) {
    body['IsSingleTransfer'] = request.isSingleTransfer;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.targetAccountName)) {
    body['TargetAccountName'] = request.targetAccountName;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'TransferCallToAgent',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function transferCallToAgent(request: TransferCallToAgentRequest): TransferCallToAgentResponse {
  var runtime = new Util.RuntimeOptions{};
  return transferCallToAgentWithOptions(request, runtime);
}

model TransferCallToPhoneRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  callee?: string(name='Callee'),
  caller?: string(name='Caller'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  holdConnectionId?: string(name='HoldConnectionId'),
  instanceId?: string(name='InstanceId'),
  isSingleTransfer?: boolean(name='IsSingleTransfer'),
  jobId?: string(name='JobId'),
  type?: int32(name='Type'),
  calleePhone?: string(name='calleePhone'),
  callerPhone?: string(name='callerPhone'),
}

model TransferCallToPhoneResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model TransferCallToPhoneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: TransferCallToPhoneResponseBody(name='body'),
}

async function transferCallToPhoneWithOptions(request: TransferCallToPhoneRequest, runtime: Util.RuntimeOptions): TransferCallToPhoneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.callee)) {
    body['Callee'] = request.callee;
  }
  if (!Util.isUnset(request.caller)) {
    body['Caller'] = request.caller;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.holdConnectionId)) {
    body['HoldConnectionId'] = request.holdConnectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.isSingleTransfer)) {
    body['IsSingleTransfer'] = request.isSingleTransfer;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  if (!Util.isUnset(request.calleePhone)) {
    body['calleePhone'] = request.calleePhone;
  }
  if (!Util.isUnset(request.callerPhone)) {
    body['callerPhone'] = request.callerPhone;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'TransferCallToPhone',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function transferCallToPhone(request: TransferCallToPhoneRequest): TransferCallToPhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return transferCallToPhoneWithOptions(request, runtime);
}

model TransferCallToSkillGroupRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  holdConnectionId?: string(name='HoldConnectionId'),
  instanceId?: string(name='InstanceId'),
  isSingleTransfer?: boolean(name='IsSingleTransfer'),
  jobId?: string(name='JobId'),
  skillGroupId?: long(name='SkillGroupId'),
  type?: int32(name='Type'),
}

model TransferCallToSkillGroupResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model TransferCallToSkillGroupResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: TransferCallToSkillGroupResponseBody(name='body'),
}

async function transferCallToSkillGroupWithOptions(request: TransferCallToSkillGroupRequest, runtime: Util.RuntimeOptions): TransferCallToSkillGroupResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.holdConnectionId)) {
    body['HoldConnectionId'] = request.holdConnectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.isSingleTransfer)) {
    body['IsSingleTransfer'] = request.isSingleTransfer;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  if (!Util.isUnset(request.skillGroupId)) {
    body['SkillGroupId'] = request.skillGroupId;
  }
  if (!Util.isUnset(request.type)) {
    body['Type'] = request.type;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'TransferCallToSkillGroup',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function transferCallToSkillGroup(request: TransferCallToSkillGroupRequest): TransferCallToSkillGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return transferCallToSkillGroupWithOptions(request, runtime);
}

model TransferToThirdCallRequest {
  accountName?: string(name='AccountName'),
  callId?: string(name='CallId'),
  clientToken?: string(name='ClientToken'),
  connectionId?: string(name='ConnectionId'),
  holdConnectionId?: string(name='HoldConnectionId'),
  instanceId?: string(name='InstanceId'),
  jobId?: string(name='JobId'),
}

model TransferToThirdCallResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model TransferToThirdCallResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: TransferToThirdCallResponseBody(name='body'),
}

async function transferToThirdCallWithOptions(request: TransferToThirdCallRequest, runtime: Util.RuntimeOptions): TransferToThirdCallResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.callId)) {
    body['CallId'] = request.callId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.connectionId)) {
    body['ConnectionId'] = request.connectionId;
  }
  if (!Util.isUnset(request.holdConnectionId)) {
    body['HoldConnectionId'] = request.holdConnectionId;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.jobId)) {
    body['JobId'] = request.jobId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'TransferToThirdCall',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function transferToThirdCall(request: TransferToThirdCallRequest): TransferToThirdCallResponse {
  var runtime = new Util.RuntimeOptions{};
  return transferToThirdCallWithOptions(request, runtime);
}

model UnbindAgentHotlinePhoneRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
}

model UnbindAgentHotlinePhoneResponseBody = {
  code?: string(name='Code'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UnbindAgentHotlinePhoneResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UnbindAgentHotlinePhoneResponseBody(name='body'),
}

async function unbindAgentHotlinePhoneWithOptions(request: UnbindAgentHotlinePhoneRequest, runtime: Util.RuntimeOptions): UnbindAgentHotlinePhoneResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UnbindAgentHotlinePhone',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function unbindAgentHotlinePhone(request: UnbindAgentHotlinePhoneRequest): UnbindAgentHotlinePhoneResponse {
  var runtime = new Util.RuntimeOptions{};
  return unbindAgentHotlinePhoneWithOptions(request, runtime);
}

model UpdateAgentRequest {
  accountName?: string(name='AccountName'),
  clientToken?: string(name='ClientToken'),
  displayName?: string(name='DisplayName'),
  instanceId?: string(name='InstanceId'),
  skillGroupId?: [ long ](name='SkillGroupId'),
  skillGroupIdList?: [ long ](name='SkillGroupIdList'),
}

model UpdateAgentResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateAgentResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateAgentResponseBody(name='body'),
}

async function updateAgentWithOptions(request: UpdateAgentRequest, runtime: Util.RuntimeOptions): UpdateAgentResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.accountName)) {
    body['AccountName'] = request.accountName;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.displayName)) {
    body['DisplayName'] = request.displayName;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.skillGroupId)) {
    body['SkillGroupId'] = request.skillGroupId;
  }
  if (!Util.isUnset(request.skillGroupIdList)) {
    body['SkillGroupIdList'] = request.skillGroupIdList;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateAgent',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'PUT',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateAgent(request: UpdateAgentRequest): UpdateAgentResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateAgentWithOptions(request, runtime);
}

model UpdateCustomerRequest {
  bizType?: string(name='BizType'),
  contacter?: string(name='Contacter'),
  customerId?: long(name='CustomerId'),
  dingding?: string(name='Dingding'),
  email?: string(name='Email'),
  industry?: string(name='Industry'),
  instanceId?: string(name='InstanceId'),
  managerName?: string(name='ManagerName'),
  name?: string(name='Name'),
  outerId?: string(name='OuterId'),
  outerIdType?: int32(name='OuterIdType'),
  phone?: string(name='Phone'),
  position?: string(name='Position'),
  prodLineId?: long(name='ProdLineId'),
  typeCode?: string(name='TypeCode'),
}

model UpdateCustomerResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateCustomerResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateCustomerResponseBody(name='body'),
}

async function updateCustomerWithOptions(request: UpdateCustomerRequest, runtime: Util.RuntimeOptions): UpdateCustomerResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.bizType)) {
    query['BizType'] = request.bizType;
  }
  if (!Util.isUnset(request.contacter)) {
    query['Contacter'] = request.contacter;
  }
  if (!Util.isUnset(request.customerId)) {
    query['CustomerId'] = request.customerId;
  }
  if (!Util.isUnset(request.dingding)) {
    query['Dingding'] = request.dingding;
  }
  if (!Util.isUnset(request.email)) {
    query['Email'] = request.email;
  }
  if (!Util.isUnset(request.industry)) {
    query['Industry'] = request.industry;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.managerName)) {
    query['ManagerName'] = request.managerName;
  }
  if (!Util.isUnset(request.name)) {
    query['Name'] = request.name;
  }
  if (!Util.isUnset(request.outerId)) {
    query['OuterId'] = request.outerId;
  }
  if (!Util.isUnset(request.outerIdType)) {
    query['OuterIdType'] = request.outerIdType;
  }
  if (!Util.isUnset(request.phone)) {
    query['Phone'] = request.phone;
  }
  if (!Util.isUnset(request.position)) {
    query['Position'] = request.position;
  }
  if (!Util.isUnset(request.prodLineId)) {
    query['ProdLineId'] = request.prodLineId;
  }
  if (!Util.isUnset(request.typeCode)) {
    query['TypeCode'] = request.typeCode;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateCustomer',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateCustomer(request: UpdateCustomerRequest): UpdateCustomerResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateCustomerWithOptions(request, runtime);
}

model UpdateEntityTagRelationRequest {
  entityTagParam?: string(name='EntityTagParam'),
  instanceId?: string(name='InstanceId'),
}

model UpdateEntityTagRelationResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateEntityTagRelationResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateEntityTagRelationResponseBody(name='body'),
}

async function updateEntityTagRelationWithOptions(request: UpdateEntityTagRelationRequest, runtime: Util.RuntimeOptions): UpdateEntityTagRelationResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.entityTagParam)) {
    body['EntityTagParam'] = request.entityTagParam;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateEntityTagRelation',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateEntityTagRelation(request: UpdateEntityTagRelationRequest): UpdateEntityTagRelationResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateEntityTagRelationWithOptions(request, runtime);
}

model UpdateRingStatusRequest {
  callOutStatus?: string(name='CallOutStatus'),
  extra?: string(name='Extra'),
  instanceId?: string(name='InstanceId'),
  uniqueBizId?: string(name='UniqueBizId'),
}

model UpdateRingStatusResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateRingStatusResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateRingStatusResponseBody(name='body'),
}

async function updateRingStatusWithOptions(request: UpdateRingStatusRequest, runtime: Util.RuntimeOptions): UpdateRingStatusResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.callOutStatus)) {
    body['CallOutStatus'] = request.callOutStatus;
  }
  if (!Util.isUnset(request.extra)) {
    body['Extra'] = request.extra;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.uniqueBizId)) {
    body['UniqueBizId'] = request.uniqueBizId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateRingStatus',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateRingStatus(request: UpdateRingStatusRequest): UpdateRingStatusResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateRingStatusWithOptions(request, runtime);
}

model UpdateRoleRequest {
  clientToken?: string(name='ClientToken'),
  instanceId?: string(name='InstanceId'),
  operator?: string(name='Operator'),
  permissionId?: [ long ](name='PermissionId'),
  roleId?: long(name='RoleId'),
  roleName?: string(name='RoleName'),
}

model UpdateRoleResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateRoleResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateRoleResponseBody(name='body'),
}

async function updateRoleWithOptions(request: UpdateRoleRequest, runtime: Util.RuntimeOptions): UpdateRoleResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operator)) {
    body['Operator'] = request.operator;
  }
  if (!Util.isUnset(request.permissionId)) {
    body['PermissionId'] = request.permissionId;
  }
  if (!Util.isUnset(request.roleId)) {
    body['RoleId'] = request.roleId;
  }
  if (!Util.isUnset(request.roleName)) {
    body['RoleName'] = request.roleName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateRole',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateRole(request: UpdateRoleRequest): UpdateRoleResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateRoleWithOptions(request, runtime);
}

model UpdateSkillGroupRequest {
  channelType?: long(name='ChannelType'),
  clientToken?: string(name='ClientToken'),
  description?: string(name='Description'),
  displayName?: string(name='DisplayName'),
  instanceId?: string(name='InstanceId'),
  skillGroupId?: long(name='SkillGroupId'),
  skillGroupName?: string(name='SkillGroupName'),
}

model UpdateSkillGroupResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateSkillGroupResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateSkillGroupResponseBody(name='body'),
}

async function updateSkillGroupWithOptions(request: UpdateSkillGroupRequest, runtime: Util.RuntimeOptions): UpdateSkillGroupResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.channelType)) {
    query['ChannelType'] = request.channelType;
  }
  if (!Util.isUnset(request.clientToken)) {
    query['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.description)) {
    query['Description'] = request.description;
  }
  if (!Util.isUnset(request.displayName)) {
    query['DisplayName'] = request.displayName;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.skillGroupId)) {
    query['SkillGroupId'] = request.skillGroupId;
  }
  if (!Util.isUnset(request.skillGroupName)) {
    query['SkillGroupName'] = request.skillGroupName;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'UpdateSkillGroup',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateSkillGroup(request: UpdateSkillGroupRequest): UpdateSkillGroupResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateSkillGroupWithOptions(request, runtime);
}

model UpdateTicketRequest {
  clientToken?: string(name='ClientToken'),
  formData?: string(name='FormData'),
  instanceId?: string(name='InstanceId'),
  operatorId?: long(name='OperatorId'),
  ticketId?: long(name='TicketId'),
}

model UpdateTicketResponseBody = {
  code?: string(name='Code'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model UpdateTicketResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: UpdateTicketResponseBody(name='body'),
}

async function updateTicketWithOptions(request: UpdateTicketRequest, runtime: Util.RuntimeOptions): UpdateTicketResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.formData)) {
    body['FormData'] = request.formData;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.operatorId)) {
    body['OperatorId'] = request.operatorId;
  }
  if (!Util.isUnset(request.ticketId)) {
    body['TicketId'] = request.ticketId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'UpdateTicket',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function updateTicket(request: UpdateTicketRequest): UpdateTicketResponse {
  var runtime = new Util.RuntimeOptions{};
  return updateTicketWithOptions(request, runtime);
}

model XspaceNextbotChatRequest {
  channel?: string(name='Channel'),
  conversationId?: string(name='ConversationId'),
  instanceId?: string(name='InstanceId'),
  knowledgeId?: string(name='KnowledgeId'),
  question?: string(name='Question'),
  robotId?: string(name='RobotId'),
  senderId?: string(name='SenderId'),
  senderNick?: string(name='SenderNick'),
  sessionId?: string(name='SessionId'),
  tenantId?: long(name='TenantId'),
}

model XspaceNextbotChatResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model XspaceNextbotChatResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: XspaceNextbotChatResponseBody(name='body'),
}

async function xspaceNextbotChatWithOptions(request: XspaceNextbotChatRequest, runtime: Util.RuntimeOptions): XspaceNextbotChatResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.channel)) {
    query['Channel'] = request.channel;
  }
  if (!Util.isUnset(request.conversationId)) {
    query['ConversationId'] = request.conversationId;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.knowledgeId)) {
    query['KnowledgeId'] = request.knowledgeId;
  }
  if (!Util.isUnset(request.question)) {
    query['Question'] = request.question;
  }
  if (!Util.isUnset(request.robotId)) {
    query['RobotId'] = request.robotId;
  }
  if (!Util.isUnset(request.senderId)) {
    query['SenderId'] = request.senderId;
  }
  if (!Util.isUnset(request.senderNick)) {
    query['SenderNick'] = request.senderNick;
  }
  if (!Util.isUnset(request.sessionId)) {
    query['SessionId'] = request.sessionId;
  }
  if (!Util.isUnset(request.tenantId)) {
    query['TenantId'] = request.tenantId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'XspaceNextbotChat',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function xspaceNextbotChat(request: XspaceNextbotChatRequest): XspaceNextbotChatResponse {
  var runtime = new Util.RuntimeOptions{};
  return xspaceNextbotChatWithOptions(request, runtime);
}

model XspaceNextbotCreatTenantRequest {
  buId?: string(name='BuId'),
  buName?: string(name='BuName'),
  instanceId?: string(name='InstanceId'),
}

model XspaceNextbotCreatTenantResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model XspaceNextbotCreatTenantResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: XspaceNextbotCreatTenantResponseBody(name='body'),
}

async function xspaceNextbotCreatTenantWithOptions(request: XspaceNextbotCreatTenantRequest, runtime: Util.RuntimeOptions): XspaceNextbotCreatTenantResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.buId)) {
    query['BuId'] = request.buId;
  }
  if (!Util.isUnset(request.buName)) {
    query['BuName'] = request.buName;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'XspaceNextbotCreatTenant',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function xspaceNextbotCreatTenant(request: XspaceNextbotCreatTenantRequest): XspaceNextbotCreatTenantResponse {
  var runtime = new Util.RuntimeOptions{};
  return xspaceNextbotCreatTenantWithOptions(request, runtime);
}

model XspaceNextbotInitTenantRequest {
  account?: string(name='Account'),
  accountType?: string(name='AccountType'),
  instanceId?: string(name='InstanceId'),
  kwLibrary?: string(name='KwLibrary'),
  productEndTime?: long(name='ProductEndTime'),
  productStartTime?: long(name='ProductStartTime'),
  productValidPeriod?: long(name='ProductValidPeriod'),
  tenantDesc?: string(name='TenantDesc'),
  tenantId?: string(name='TenantId'),
  tenantName?: string(name='TenantName'),
  version?: string(name='Version'),
}

model XspaceNextbotInitTenantResponseBody = {
  code?: string(name='Code'),
  data?: string(name='Data'),
  httpStatusCode?: long(name='HttpStatusCode'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model XspaceNextbotInitTenantResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: XspaceNextbotInitTenantResponseBody(name='body'),
}

async function xspaceNextbotInitTenantWithOptions(request: XspaceNextbotInitTenantRequest, runtime: Util.RuntimeOptions): XspaceNextbotInitTenantResponse {
  Util.validateModel(request);
  var query = {};
  if (!Util.isUnset(request.account)) {
    query['Account'] = request.account;
  }
  if (!Util.isUnset(request.accountType)) {
    query['AccountType'] = request.accountType;
  }
  if (!Util.isUnset(request.instanceId)) {
    query['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.kwLibrary)) {
    query['KwLibrary'] = request.kwLibrary;
  }
  if (!Util.isUnset(request.productEndTime)) {
    query['ProductEndTime'] = request.productEndTime;
  }
  if (!Util.isUnset(request.productStartTime)) {
    query['ProductStartTime'] = request.productStartTime;
  }
  if (!Util.isUnset(request.productValidPeriod)) {
    query['ProductValidPeriod'] = request.productValidPeriod;
  }
  if (!Util.isUnset(request.tenantDesc)) {
    query['TenantDesc'] = request.tenantDesc;
  }
  if (!Util.isUnset(request.tenantId)) {
    query['TenantId'] = request.tenantId;
  }
  if (!Util.isUnset(request.tenantName)) {
    query['TenantName'] = request.tenantName;
  }
  if (!Util.isUnset(request.version)) {
    query['Version'] = request.version;
  }
  var req = new OpenApi.OpenApiRequest{ 
    query = OpenApiUtil.query(query),
  };
  var params = new OpenApi.Params{
    action = 'XspaceNextbotInitTenant',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function xspaceNextbotInitTenant(request: XspaceNextbotInitTenantRequest): XspaceNextbotInitTenantResponse {
  var runtime = new Util.RuntimeOptions{};
  return xspaceNextbotInitTenantWithOptions(request, runtime);
}

model CreateTicketWithBizDataRequest {
  bizData?: string(name='BizData'),
  carbonCopy?: string(name='CarbonCopy'),
  categoryId?: long(name='CategoryId'),
  clientToken?: string(name='ClientToken'),
  creatorId?: long(name='CreatorId'),
  creatorName?: string(name='CreatorName'),
  creatorType?: int32(name='CreatorType'),
  formData?: string(name='FormData'),
  fromInfo?: string(name='FromInfo'),
  instanceId?: string(name='InstanceId'),
  memberId?: long(name='MemberId'),
  memberName?: string(name='MemberName'),
  priority?: int32(name='Priority'),
  templateId?: long(name='TemplateId'),
}

model CreateTicketWithBizDataResponseBody = {
  code?: string(name='Code'),
  data?: long(name='Data'),
  message?: string(name='Message'),
  requestId?: string(name='RequestId'),
  success?: boolean(name='Success'),
}

model CreateTicketWithBizDataResponse = {
  headers: map[string]string(name='headers'),
  statusCode: int32(name='statusCode'),
  body: CreateTicketWithBizDataResponseBody(name='body'),
}

async function createTicketWithBizDataWithOptions(request: CreateTicketWithBizDataRequest, runtime: Util.RuntimeOptions): CreateTicketWithBizDataResponse {
  Util.validateModel(request);
  var body : map[string]any = {};
  if (!Util.isUnset(request.bizData)) {
    body['BizData'] = request.bizData;
  }
  if (!Util.isUnset(request.carbonCopy)) {
    body['CarbonCopy'] = request.carbonCopy;
  }
  if (!Util.isUnset(request.categoryId)) {
    body['CategoryId'] = request.categoryId;
  }
  if (!Util.isUnset(request.clientToken)) {
    body['ClientToken'] = request.clientToken;
  }
  if (!Util.isUnset(request.creatorId)) {
    body['CreatorId'] = request.creatorId;
  }
  if (!Util.isUnset(request.creatorName)) {
    body['CreatorName'] = request.creatorName;
  }
  if (!Util.isUnset(request.creatorType)) {
    body['CreatorType'] = request.creatorType;
  }
  if (!Util.isUnset(request.formData)) {
    body['FormData'] = request.formData;
  }
  if (!Util.isUnset(request.fromInfo)) {
    body['FromInfo'] = request.fromInfo;
  }
  if (!Util.isUnset(request.instanceId)) {
    body['InstanceId'] = request.instanceId;
  }
  if (!Util.isUnset(request.memberId)) {
    body['MemberId'] = request.memberId;
  }
  if (!Util.isUnset(request.memberName)) {
    body['MemberName'] = request.memberName;
  }
  if (!Util.isUnset(request.priority)) {
    body['Priority'] = request.priority;
  }
  if (!Util.isUnset(request.templateId)) {
    body['TemplateId'] = request.templateId;
  }
  var req = new OpenApi.OpenApiRequest{ 
    body = OpenApiUtil.parseToMap(body),
  };
  var params = new OpenApi.Params{
    action = 'createTicketWithBizData',
    version = '2020-07-02',
    protocol = 'HTTPS',
    pathname = '/',
    method = 'POST',
    authType = 'AK',
    style = 'RPC',
    reqBodyType = 'formData',
    bodyType = 'json',
  };
  return callApi(params, req, runtime);
}

async function createTicketWithBizData(request: CreateTicketWithBizDataRequest): CreateTicketWithBizDataResponse {
  var runtime = new Util.RuntimeOptions{};
  return createTicketWithBizDataWithOptions(request, runtime);
}