/* eslint-disable */
|
// @ts-ignore
|
import { request } from '@/utils/request';
|
|
/** 新增用户认证审核信息 POST /api/User/AddUserCertificationAudit */
|
export async function addUserCertificationAudit(
|
body: API.AddUserCertificationAuditInput,
|
options?: API.RequestConfig
|
) {
|
return request<API.AddUserCertificationAuditDto>('/api/User/AddUserCertificationAudit', {
|
method: 'POST',
|
headers: {
|
'Content-Type': 'application/json',
|
},
|
data: body,
|
...(options || {}),
|
});
|
}
|
|
/** 申请用户证书 POST /api/User/ApplyUserCertificate */
|
export async function applyUserCertificate(
|
body: API.ApplyUserCertificateInput,
|
options?: API.RequestConfig
|
) {
|
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,
|
},
|
...(options || {}),
|
});
|
}
|
|
/** 校验用户认证手机号
|
版本说明：用户认证的信息发生改变 POST /api/User/CheckUserThreamVerificationCode */
|
export async function checkUserThreamVerificationCode(
|
body: API.CheckPhoneVerificationCodeInput,
|
options?: API.RequestConfig
|
) {
|
return request<boolean>('/api/User/CheckUserThreamVerificationCode', {
|
method: 'POST',
|
headers: {
|
'Content-Type': 'application/json',
|
},
|
data: body,
|
...(options || {}),
|
});
|
}
|
|
/** 提交企业认证 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',
|
},
|
data: body,
|
...(options || {}),
|
});
|
}
|
|
/** 新建企业用户 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',
|
},
|
data: body,
|
...(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 || {}),
|
});
|
}
|
