feat: init

wupengfei

2025-04-03 100740a5b4e512b5b3c9b3e9ecb467cb7384b791

 src/services/api/User.ts

@@ -2,64 +2,12 @@
// @ts-ignore
import { request } from '@/utils/request';

/** 新增账号信息 POST /api/User/CreateAccount */
export async function createAccount(body: API.CreateAccountInput, options?: API.RequestConfig) {
  return request<string>('/api/User/CreateAccount', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /api/User/CreateRole */
export async function createRole(body: API.CreateOrUpdateRoleInput, options?: API.RequestConfig) {
  return request<string>('/api/User/CreateRole', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /api/User/DeleteRole */
export async function deleteRole(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteRoleParams,
/** 新增用户认证审核信息 POST /api/User/AddUserCertificationAudit */
export async function addUserCertificationAudit(
  body: API.AddUserCertificationAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/DeleteRole', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取所有角色 GET /api/User/GetAllRoles */
export async function getAllRoles(options?: API.RequestConfig) {
  return request<API.RoleInfo[]>('/api/User/GetAllRoles', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /api/User/GetOssSTS */
export async function getOssSTS(options?: API.RequestConfig) {
  return request<API.OssSTSReponse>('/api/User/GetOssSTS', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 获取角色分页列表 POST /api/User/GetRoles */
export async function getRoles(body: API.GetRolesInput, options?: API.RequestConfig) {
  return request<API.RoleInfoPageOutput>('/api/User/GetRoles', {
  return request<API.AddUserCertificationAuditDto>('/api/User/AddUserCertificationAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
@@ -69,25 +17,76 @@
  });
}

/** 获取token POST /api/User/GetTokenForWeb */
export async function getTokenForWeb(body: API.AccessRequestDto, options?: API.RequestConfig) {
  return request<API.IdentityModelTokenCacheItem>('/api/User/GetTokenForWeb', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取用户详情 GET /api/User/GetUserDetail */
export async function getUserDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserDetailParams,
/** 申请用户证书 POST /api/User/ApplyUserCertificate */
export async function applyUserCertificate(
  body: API.ApplyUserCertificateInput,
  options?: API.RequestConfig
) {
  return request<API.UserDetailOutput>('/api/User/GetUserDetail', {
  return request<number>('/api/User/ApplyUserCertificate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 批量创建认证用户 POST /api/User/BatchCreateCompanyUser */
export async function batchCreateCompanyUser(
  body: API.AddCertifiedUserInput[],
  options?: API.RequestConfig
) {
  return request<string[]>('/api/User/BatchCreateCompanyUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 校验批量创建认证用户数据 POST /api/User/CheckBatchCreateCompanyUserData */
export async function checkBatchCreateCompanyUserData(
  body: API.CheckBatchCreateCompanyUserInput[],
  options?: API.RequestConfig
) {
  return request<API.CheckBatchCreateCompanyUserResult[]>(
    '/api/User/CheckBatchCreateCompanyUserData',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 校验用户认证审核验证码 POST /api/User/CheckUserCertificationAuditVerificationCode */
export async function checkUserCertificationAuditVerificationCode(
  body: API.CheckPhoneVerificationCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/CheckUserCertificationAuditVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 校验认证信息重复 GET /api/User/CheckUserCertificationRepeat */
export async function checkUserCertificationRepeat(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIcheckUserCertificationRepeatParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/User/CheckUserCertificationRepeat', {
    method: 'GET',
    params: {
      ...params,
@@ -96,36 +95,13 @@
  });
}

/** 获取用户分页列表 POST /api/User/GetUserPage */
export async function getUserPage(body: API.QueryUserPageInput, options?: API.RequestConfig) {
  return request<API.UserListOutputPageOutput>('/api/User/GetUserPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 密码登录 POST /api/User/PasswordLogin */
export async function passwordLogin(body: API.PasswordLoginInput, options?: API.RequestConfig) {
  return request<API.IdentityModelTokenCacheItem>('/api/User/PasswordLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /api/User/RoleEnableOrForbid */
export async function roleEnableOrForbid(
  body: API.RoleEnableOrForbidInput,
/** 校验用户认证手机号
版本说明：用户认证的信息发生改变 POST /api/User/CheckUserThreamVerificationCode */
export async function checkUserThreamVerificationCode(
  body: API.CheckPhoneVerificationCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/RoleEnableOrForbid', {
  return request<boolean>('/api/User/CheckUserThreamVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
@@ -135,9 +111,12 @@
  });
}

/** 更新账号信息 POST /api/User/UpdateAccount */
export async function updateAccount(body: API.UpdateAccountInput, options?: API.RequestConfig) {
  return request<number>('/api/User/UpdateAccount', {
/** 提交企业认证 POST /api/User/CompanyAttestationSubmit */
export async function companyAttestationSubmit(
  body: API.CompanyAttestationSubmitInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/CompanyAttestationSubmit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
@@ -147,9 +126,12 @@
  });
}

/** 此处后端没有提供注释 POST /api/User/UpdateRole */
export async function updateRole(body: API.CreateOrUpdateRoleInput, options?: API.RequestConfig) {
  return request<number>('/api/User/UpdateRole', {
/** 新建企业用户 POST /api/User/CreateCompanyUser */
export async function createCompanyUser(
  body: API.AddCertifiedUserInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/User/CreateCompanyUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
@@ -158,3 +140,717 @@
    ...(options || {}),
  });
}

/** 创建认证信息 POST /api/User/CreateUserCertification */
export async function createUserCertification(
  body: API.AddUserCertificationBaseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/CreateUserCertification', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 关注用户 POST /api/User/FollowUser */
export async function followUser(body: API.FollowUserInput, options?: API.RequestConfig) {
  return request<number>('/api/User/FollowUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 企业用户列表 POST /api/User/GetAllCompanyUsers */
export async function getAllCompanyUsers(
  body: API.GeAlltCompanyUsersInput,
  options?: API.RequestConfig
) {
  return request<API.CompanyUserDto[]>('/api/User/GetAllCompanyUsers', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 平台用户 POST /api/User/GetAllPlatUserAttestation */
export async function getAllPlatUserAttestation(
  body: API.GetAllAttestationsInputV2,
  options?: API.RequestConfig
) {
  return request<API.PlatUserAttestationDtoPageOutput>('/api/User/GetAllPlatUserAttestation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取所有平台用户 POST /api/User/GetAllPlatUserAttestationList */
export async function getAllPlatUserAttestationList(
  body: API.GetAllAttestationsInputV2,
  options?: API.RequestConfig
) {
  return request<API.AttestationV2Info[]>('/api/User/GetAllPlatUserAttestationList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取企业提交认证信息 GET /api/User/GetCompanyAttestation */
export async function getCompanyAttestation(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCompanyAttestationParams,
  options?: API.RequestConfig
) {
  return request<API.CompanyAttestationDto>('/api/User/GetCompanyAttestation', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 企业用户详情 GET /api/User/GetCompanyUser */
export async function getCompanyUser(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCompanyUserParams,
  options?: API.RequestConfig
) {
  return request<API.CertifiedUserDetailDto>('/api/User/GetCompanyUser', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取认证用户详情信息
版本说明：用户认证信息的表更改 GET /api/User/GetCompanyUserByUserId */
export async function getCompanyUserByUserId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCompanyUserByUserIdParams,
  options?: API.RequestConfig
) {
  return request<API.CertifiedUserDetailDto>('/api/User/GetCompanyUserByUserId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 企业用户列表 POST /api/User/GetCompanyUsers */
export async function getCompanyUsers(
  body: API.QueryCertifiedUserListInput,
  options?: API.RequestConfig
) {
  return request<API.CertifiedUserListDtoPageOutput>('/api/User/GetCompanyUsers', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 自营客户目录 GET /api/User/GetCustomers */
export async function getCustomers(options?: API.RequestConfig) {
  return request<API.CustomerMenu[]>('/api/User/GetCustomers', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取粉丝分页列表 POST /api/User/GetFansFollowUserPage */
export async function getFansFollowUserPage(body: API.PageInput, options?: API.RequestConfig) {
  return request<API.FollowUserListOutputPageOutput>('/api/User/GetFansFollowUserPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取关注分页列表 POST /api/User/GetFollowUserPage */
export async function getFollowUserPage(body: API.PageInput, options?: API.RequestConfig) {
  return request<API.FollowUserListOutputPageOutput>('/api/User/GetFollowUserPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取互相关注分页列表 POST /api/User/GetMutualFollowUserPage */
export async function getMutualFollowUserPage(body: API.PageInput, options?: API.RequestConfig) {
  return request<API.FollowUserListOutputPageOutput>('/api/User/GetMutualFollowUserPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取用户个人中心认证审核信息 GET /api/User/GetMyCertificationAuditInfo */
export async function getMyCertificationAuditInfo(options?: API.RequestConfig) {
  return request<API.MyCertificationAuditDto>('/api/User/GetMyCertificationAuditInfo', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取个人提交认证信息 GET /api/User/GetPersonalAttestation */
export async function getPersonalAttestation(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPersonalAttestationParams,
  options?: API.RequestConfig
) {
  return request<API.PersonalAttestationDto>('/api/User/GetPersonalAttestation', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 个人用户详情 GET /api/User/GetPersonalUser */
export async function getPersonalUser(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPersonalUserParams,
  options?: API.RequestConfig
) {
  return request<API.PersonalUserDetail>('/api/User/GetPersonalUser', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 个人用户列表 POST /api/User/GetPersonalUsers */
export async function getPersonalUsers(
  body: API.GetPersonalUsersInput,
  options?: API.RequestConfig
) {
  return request<API.PersonalUserDtoPageOutput>('/api/User/GetPersonalUsers', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取平台用户详情 GET /api/User/GetPlatUserAttestationInfo */
export async function getPlatUserAttestationInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPlatUserAttestationInfoParams,
  options?: API.RequestConfig
) {
  return request<API.PlatUserAttestationInfoDto>('/api/User/GetPlatUserAttestationInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 认证审核列表 POST /api/User/GetUserAttestations */
export async function getUserAttestations(
  body: API.GetUserAttestationsInput,
  options?: API.RequestConfig
) {
  return request<API.UserAttestationDtoPageOutput>('/api/User/GetUserAttestations', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取用户证书申请状态 GET /api/User/GetUserBestSignUserRegStatus */
export async function getUserBestSignUserRegStatus(options?: API.RequestConfig) {
  return request<number>('/api/User/GetUserBestSignUserRegStatus', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取用户名片 GET /api/User/GetUserCardById */
export async function getUserCardById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserCardByIdParams,
  options?: API.RequestConfig
) {
  return request<API.UserCardDto>('/api/User/GetUserCardById', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取用户认证审核明细信息 GET /api/User/GetUserCertificationAuditDetailById */
export async function getUserCertificationAuditDetailById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserCertificationAuditDetailByIdParams,
  options?: API.RequestConfig
) {
  return request<API.UserCertificationAuditDetailDto>(
    '/api/User/GetUserCertificationAuditDetailById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取用户认证审核分页列表 POST /api/User/GetUserCertificationAuditListPage */
export async function getUserCertificationAuditListPage(
  body: API.QueryUserCertificationAuditListInput,
  options?: API.RequestConfig
) {
  return request<API.UserCertificationAuditListDtoPageOutput>(
    '/api/User/GetUserCertificationAuditListPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取认证审核状态 GET /api/User/GetUserCertificationAuditStatus */
export async function getUserCertificationAuditStatus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserCertificationAuditStatusParams,
  options?: API.RequestConfig
) {
  return request<API.UserCertificationAuditStatusEnum>(
    '/api/User/GetUserCertificationAuditStatus',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取用户认认证下拉数据列表 POST /api/User/GetUserCertificationDropdownDataList */
export async function getUserCertificationDropdownDataList(
  body: API.QueryUserCertificationDropdownDataInput,
  options?: API.RequestConfig
) {
  return request<API.UserCertificationDropdownDataDto[]>(
    '/api/User/GetUserCertificationDropdownDataList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取认证管理分页列表 POST /api/User/GetUserCertifiedManagerPage */
export async function getUserCertifiedManagerPage(
  body: API.QueryCertifiedUserListInput,
  options?: API.RequestConfig
) {
  return request<API.CertifiedUserListDtoPageOutput>('/api/User/GetUserCertifiedManagerPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 小程序端--获取用户 互相关注 关注 粉丝 GET /api/User/GetUserFollowInfo */
export async function getUserFollowInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserFollowInfoParams,
  options?: API.RequestConfig
) {
  return request<API.GetUserFollowInfoOutput>('/api/User/GetUserFollowInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取登录用户信息 GET /api/User/GetUserInfo */
export async function getUserInfo(options?: API.RequestConfig) {
  return request<API.UserInfoV2>('/api/User/GetUserInfo', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取用户基本信息V2版本
版本说明：用户认证的信息发生改变 GET /api/User/GetUserInfoV2 */
export async function getUserInfoV2(options?: API.RequestConfig) {
  return request<API.UserInfoV2>('/api/User/GetUserInfoV2', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取用户简单信息 GET /api/User/GetUserSimpleInfo */
export async function getUserSimpleInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserSimpleInfoParams,
  options?: API.RequestConfig
) {
  return request<API.UserSimpleInfo>('/api/User/GetUserSimpleInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取小程序 关注、粉丝、获赞、互关 GET /api/User/GetUserTotalInfo */
export async function getUserTotalInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserTotalInfoParams,
  options?: API.RequestConfig
) {
  return request<API.GetUserTotalInfoOutput>('/api/User/GetUserTotalInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取用户钱包签章状态 GET /api/User/GetUserWalletSignStatus */
export async function getUserWalletSignStatus(options?: API.RequestConfig) {
  return request<API.UserWalletSignStatusOutput>('/api/User/GetUserWalletSignStatus', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 根据用户Id失效用户认证 POST /api/User/InvalidUserCertificationByUserId */
export async function invalidUserCertificationByUserId(
  body: API.BaseIdInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/InvalidUserCertificationByUserId', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 提交个人认证 POST /api/User/PersonalAttestationSubmit */
export async function personalAttestationSubmit(
  body: API.PersonalAttestationSubmitInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/PersonalAttestationSubmit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 发送用户认证审核验证码 POST /api/User/SendUserCertificationAuditVerificationCode */
export async function sendUserCertificationAuditVerificationCode(
  body: API.SendPhoneVerificationCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/SendUserCertificationAuditVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 发送用户认证费用发票邮件 POST /api/User/SendUserCertificationPayInvoicingEmail */
export async function sendUserCertificationPayInvoicingEmail(
  body: API.SendUserCertificationPayInvoicingEmailInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/SendUserCertificationPayInvoicingEmail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置是否能登录电子签 POST /api/User/SetCanLoginUserSign */
export async function setCanLoginUserSign(
  body: API.SetCanLoginUserSignInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/SetCanLoginUserSign', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置用户撮合交易身份 POST /api/User/SetMatchMakingIdentity */
export async function setMatchMakingIdentity(
  body: API.SetMatchMakingIdentityInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/SetMatchMakingIdentity', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置用户AuthType POST /api/User/SetUserAuthType */
export async function setUserAuthType(body: API.SetUserTypeInput, options?: API.RequestConfig) {
  return request<number>('/api/User/SetUserAuthType', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置用户认证审核状态 POST /api/User/SetUserCertificationAuditStatus */
export async function setUserCertificationAuditStatus(
  body: API.SetUserCertificationAuditStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/SetUserCertificationAuditStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 取关用户 POST /api/User/UnFollowUser */
export async function unFollowUser(body: API.UnFollowUserInput, options?: API.RequestConfig) {
  return request<number>('/api/User/UnFollowUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 企业用户编辑 POST /api/User/UpdateCompanyUser */
export async function updateCompanyUser(
  body: API.UpdateCertifiedUserInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/UpdateCompanyUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 完善基础信息 POST /api/User/UpdateUserBaseInfo */
export async function updateUserBaseInfo(
  body: API.UpdateUserBaseInfoInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/UpdateUserBaseInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新用户名片 POST /api/User/UpdateUserCard */
export async function updateUserCard(body: API.UpdateUserCardInput, options?: API.RequestConfig) {
  return request<number>('/api/User/UpdateUserCard', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 修改认证信息 POST /api/User/UpdateUserCertification */
export async function updateUserCertification(
  body: API.UpdateUserCertificationBaseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/UpdateUserCertification', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新用户认证审核信息 POST /api/User/UpdateUserCertificationAudit */
export async function updateUserCertificationAudit(
  body: API.UpdateUserCertificationAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/UpdateUserCertificationAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新用户信息 POST /api/User/UpdateUserInfo */
export async function updateUserInfo(body: API.UpdateUserInfoInput, options?: API.RequestConfig) {
  return request<number>('/api/User/UpdateUserInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 认证审核 POST /api/User/UserAttestationCheck */
export async function userAttestationCheck(
  body: API.UserAttestationCheckInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/UserAttestationCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 企业三要素认证校验 POST /api/User/UserCertificationBestSignIdentity3Check */
export async function userCertificationBestSignIdentity3Check(
  body: API.UserCertificationBestSignIdentity3CheckInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/User/UserCertificationBestSignIdentity3Check', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户认证过期 GET /api/User/UserCertificationCertifiedTest */
export async function userCertificationCertifiedTest(options?: API.RequestConfig) {
  return request<number>('/api/User/UserCertificationCertifiedTest', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 用户认证过期 GET /api/User/UserCertificationExpirationTask */
export async function userCertificationExpirationTask(options?: API.RequestConfig) {
  return request<number>('/api/User/UserCertificationExpirationTask', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 用户启用/禁用 GET /api/User/UserEnableOrForbid */
export async function userEnableOrForbid(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIuserEnableOrForbidParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/User/UserEnableOrForbid', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}