feat: init

wupengfei

2025-04-03 100740a5b4e512b5b3c9b3e9ecb467cb7384b791

feat: init

 src/services/api/Account.ts

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

/** 根据绑定邮箱判断用户是否已存在 POST /api/Account/AnyUserByBindEmail */
export async function anyUserByBindEmail(
  body: API.AnyUserByBindEmailInput,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Account/AnyUserByBindEmail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 根据手机号判断用户是否已存在 POST /api/Account/AnyUserByPhoneNumber */
export async function anyUserByPhoneNumber(
  body: API.AnyUserByPhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Account/AnyUserByPhoneNumber', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 绑定用户账户邮箱 POST /api/Account/BindUserEmail */
export async function bindUserEmail(body: API.BindUserEmailInput, options?: API.RequestConfig) {
  return request<number>('/api/Account/BindUserEmail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户根据当前密码修改密码 POST /api/Account/ChangePasswordFromCurrentPwd */
export async function changePasswordFromCurrentPwd(
  body: API.ChangePasswordFromCurrentPwdInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangePasswordFromCurrentPwd', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户根据手机号修改密码验证码 POST /api/Account/ChangePasswordFromPhoneNumber */
export async function changePasswordFromPhoneNumber(
  body: API.ChangePasswordFromPhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangePasswordFromPhoneNumber', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 未登录下根据手机号修改密码验证码(忘记密码) POST /api/Account/ChangePasswordWithNoLogin */
export async function changePasswordWithNoLogin(
  body: API.ChangePasswordFromPhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangePasswordWithNoLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 修改账号 POST /api/Account/ChangeUserName */
export async function changeUserName(body: API.ChangeUserNameInput, options?: API.RequestConfig) {
  return request<number>('/api/Account/ChangeUserName', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 管理员更改用户登录手机号 POST /api/Account/ChangeUserPhoneNumberForAdmin */
export async function changeUserPhoneNumberForAdmin(
  body: API.ChangePhoneNumberInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangeUserPhoneNumberForAdmin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户更改登录手机号 POST /api/Account/ChangeUserPhoneNumberForUser */
export async function changeUserPhoneNumberForUser(
  body: API.ChangeUserPhoneNumberForUserInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ChangeUserPhoneNumberForUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 管理员创建用户 POST /api/Account/CreateUserForAdmin */
export async function createUserForAdmin(
  body: API.CreateUserForAdminInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/CreateUserForAdmin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 生成账号 POST /api/Account/GenerateUserName */
export async function generateUserName(
  body: API.GenerateUserNameInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Account/GenerateUserName', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取生活缴费用户身份会话信息 GET /api/Account/GetLifePayWxIndentity */
export async function getLifePayWxIndentity(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetLifePayWxIndentityParams,
  options?: API.RequestConfig
) {
  return request<API.WxMiniAppIndentityInfo>('/api/Account/GetLifePayWxIndentity', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

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

/** 获取扫码登录二维码信息 GET /api/Account/GetQrCodeForLogin */
export async function getQrCodeForLogin(options?: API.RequestConfig) {
  return request<API.QrCodeLogin>('/api/Account/GetQrCodeForLogin', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取扫码登录结果 GET /api/Account/GetQrCodeLoginResult */
export async function getQrCodeLoginResult(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetQrCodeLoginResultParams,
  options?: API.RequestConfig
) {
  return request<API.WxMiniAppLoginInfo>('/api/Account/GetQrCodeLoginResult', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 电子签登录 POST /api/Account/GetTokenForUserSign */
export async function getTokenForUserSign(body: API.AccessRequestDto, options?: API.RequestConfig) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/GetTokenForUserSign', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

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

/** 获取微信小程序用户身份会话信息 GET /api/Account/GetWxIndentity */
export async function getWxIndentity(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWxIndentityParams,
  options?: API.RequestConfig
) {
  return request<API.WxMiniAppIndentityInfo>('/api/Account/GetWxIndentity', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取学社公众号文章 GET /api/Account/GetWxPublishWriting */
export async function getWxPublishWriting(options?: API.RequestConfig) {
  return request<API.InformationShowListDtoPageOutput>('/api/Account/GetWxPublishWriting', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 判断用户绑定邮箱是否重复 GET /api/Account/IsRepeatByBindEmail */
export async function isRepeatByBindEmail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIisRepeatByBindEmailParams,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Account/IsRepeatByBindEmail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 企业名称是否重复 GET /api/Account/IsRepeatByIsRepeatByEnterpriseName */
export async function isRepeatByIsRepeatByEnterpriseName(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIisRepeatByIsRepeatByEnterpriseNameParams,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Account/IsRepeatByIsRepeatByEnterpriseName', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 判断用户手机号是否重复 GET /api/Account/IsRepeatByPhoneNumber */
export async function isRepeatByPhoneNumber(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIisRepeatByPhoneNumberParams,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Account/IsRepeatByPhoneNumber', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

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

/** 验证码登录 POST /api/Account/PhoneMesssageCodeLogin */
export async function phoneMesssageCodeLogin(
  body: API.PhoneMesssageCodeLoginInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/PhoneMesssageCodeLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 手机号验证码注册注册 POST /api/Account/PhoneMesssageCodeRegister */
export async function phoneMesssageCodeRegister(
  body: API.PhoneMesssageCodeRegisterInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/PhoneMesssageCodeRegister', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 重置密码并发送手机通知新密码 POST /api/Account/ResetPasswordWithMicroNotify */
export async function resetPasswordWithMicroNotify(
  body: API.ResetPasswordBaseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/ResetPasswordWithMicroNotify', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 发送登录注册短信验证码 POST /api/Account/SendPhoneMesssageCode */
export async function sendPhoneMesssageCode(
  body: API.SendPhoneMesssageCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/SendPhoneMesssageCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 解绑用户邮箱 POST /api/Account/UnbindingUserEmail */
export async function unbindingUserEmail(
  body: API.UnbindingUserEmailInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/UnbindingUserEmail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 解绑用户手机号 POST /api/Account/UnbindingUserPhoneNumber */
export async function unbindingUserPhoneNumber(
  body: API.UnbindingUserPhoneNumber,
  options?: API.RequestConfig
) {
  return request<number>('/api/Account/UnbindingUserPhoneNumber', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 识别营业执照 GET /api/Account/VatLicense */
export async function vatLicense(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIvatLicenseParams,
  options?: API.RequestConfig
) {
  return request<API.LicenseOcrModel>('/api/Account/VatLicense', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 小程序手机授权注册登录 POST /api/Account/WxMiniAppPhoneAuthLogin */
export async function wxMiniAppPhoneAuthLogin(
  body: API.WxMiniAppPhoneLoginInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/WxMiniAppPhoneAuthLogin', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 小程序扫码手机授权注册登录 POST /api/Account/WxMiniAppPhoneAuthLoginFromScan */
export async function wxMiniAppPhoneAuthLoginFromScan(
  body: API.WxMiniAppPhoneAuthLoginFromScanInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/WxMiniAppPhoneAuthLoginFromScan', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 已有小程序用户确认登录 GET /api/Account/WxMiniAppUserLogin */
export async function wxMiniAppUserLogin(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIwxMiniAppUserLoginParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Account/WxMiniAppUserLogin', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 已有小程序用户扫码确认登录 POST /api/Account/WxMiniAppUserLoginFromScan */
export async function wxMiniAppUserLoginFromScan(
  body: API.WxMiniAppUserLoginFromScanInput,
  options?: API.RequestConfig
) {
  return request<API.IdentityModelTokenCacheItem>('/api/Account/WxMiniAppUserLoginFromScan', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/accountAuth/GetCode */
export async function getCode(options?: API.RequestConfig) {
  return request<any>('/api/accountAuth/GetCode', {

 src/services/api/AdvertiseBoard.ts

New file
@@ -0,0 +1,93 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 创建、编辑广告位 POST /api/AdvertiseBoard/CreateOrEditAdvertiseBoard */
export async function createOrEditAdvertiseBoard(
  body: API.CreateOrEditAdvertiseBoardInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/AdvertiseBoard/CreateOrEditAdvertiseBoard', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除广告位 DELETE /api/AdvertiseBoard/DeleteAdvertiseBoard */
export async function deleteAdvertiseBoard(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteAdvertiseBoardParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/AdvertiseBoard/DeleteAdvertiseBoard', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据广告位id获取单条广告位详情 GET /api/AdvertiseBoard/GetAdvertiseBoardInfo */
export async function getAdvertiseBoardInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetAdvertiseBoardInfoParams,
  options?: API.RequestConfig
) {
  return request<API.AdvertiseBoardDto>('/api/AdvertiseBoard/GetAdvertiseBoardInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取广告位列表 POST /api/AdvertiseBoard/GetAdvertiseBoardList */
export async function getAdvertiseBoardList(
  body: API.AdvertiseBoardListInput,
  options?: API.RequestConfig
) {
  return request<API.AdvertiseBoardDtoPageOutput>('/api/AdvertiseBoard/GetAdvertiseBoardList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取全部广告位列表 POST /api/AdvertiseBoard/GetAllAdvertiseBoardList */
export async function getAllAdvertiseBoardList(
  body: API.AdvertiseBoardListInput,
  options?: API.RequestConfig
) {
  return request<API.AdvertiseBoardDto[]>('/api/AdvertiseBoard/GetAllAdvertiseBoardList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置广告位的状态 POST /api/AdvertiseBoard/SetAdvertiseBoardStatus */
export async function setAdvertiseBoardStatus(
  body: API.AdvertiseBoardStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/AdvertiseBoard/SetAdvertiseBoardStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/AdvertiseOnShow.ts

New file
@@ -0,0 +1,111 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 广告点击 POST /api/AdvertiseOnShow/AdvertiseOnShowClick */
export async function advertiseOnShowClick(
  body: API.AdvertiseOnShowClickInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/AdvertiseOnShow/AdvertiseOnShowClick', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增编辑广告 POST /api/AdvertiseOnShow/CreateOrEditAdvertiseOnShow */
export async function createOrEditAdvertiseOnShow(
  body: API.CreateOrEditAdvertiseOnShowInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/AdvertiseOnShow/CreateOrEditAdvertiseOnShow', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除广告 DELETE /api/AdvertiseOnShow/DeleteAdvertiseOnShow */
export async function deleteAdvertiseOnShow(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteAdvertiseOnShowParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/AdvertiseOnShow/DeleteAdvertiseOnShow', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取广告详情 GET /api/AdvertiseOnShow/GetAdvertiseOnShowInfo */
export async function getAdvertiseOnShowInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetAdvertiseOnShowInfoParams,
  options?: API.RequestConfig
) {
  return request<API.AdvertiseOnShowDto>('/api/AdvertiseOnShow/GetAdvertiseOnShowInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取广告列表 POST /api/AdvertiseOnShow/GetAdvertiseOnShowList */
export async function getAdvertiseOnShowList(
  body: API.AdvertiseOnShowListInput,
  options?: API.RequestConfig
) {
  return request<API.AdvertiseOnShowDtoPageOutput>('/api/AdvertiseOnShow/GetAdvertiseOnShowList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 根据页面获取该页需要呈现的广告 GET /api/AdvertiseOnShow/GetAdvertiseOnShowListByPageType */
export async function getAdvertiseOnShowListByPageType(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetAdvertiseOnShowListByPageTypeParams,
  options?: API.RequestConfig
) {
  return request<API.AdvertiseOnShowDto[]>(
    '/api/AdvertiseOnShow/GetAdvertiseOnShowListByPageType',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 设置广告状态 POST /api/AdvertiseOnShow/SetAdvertiseOnShowStatus */
export async function setAdvertiseOnShowStatus(
  body: API.AdvertiseOnShowStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/AdvertiseOnShow/SetAdvertiseOnShowStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/AliPayNotify.ts

New file
@@ -0,0 +1,34 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 支付宝充值回调通知 POST /api/AliPayNotify/AliRechargeNotify */
export async function aliRechargeNotify(options?: API.RequestConfig) {
  return request<any>('/api/AliPayNotify/AliRechargeNotify', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 单笔转账到支付宝账户、单笔转账到银行卡、C2C现金红包、B2C现金红包单据状态变更后触发的通知 POST /api/AliPayNotify/FundTransOrderChangedForRecharge */
export async function fundTransOrderChangedForRecharge(
  body: API.FundOrderChangedInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/AliPayNotify/FundTransOrderChangedForRecharge', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户签约结果通知 POST /api/AliPayNotify/NotityPageSign */
export async function notityPageSign(options?: API.RequestConfig) {
  return request<any>('/api/AliPayNotify/NotityPageSign', {
    method: 'POST',
    ...(options || {}),
  });
}

 src/services/api/Alipay.ts

New file
@@ -0,0 +1,54 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取记账本余额 GET /api/Alipay/AccountBookQuery */
export async function accountBookQuery(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIaccountBookQueryParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/Alipay/AccountBookQuery', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 支付宝充值申请 POST /api/Alipay/AlipayRecharge */
export async function alipayRecharge(body: API.AlipayRechargeInput, options?: API.RequestConfig) {
  return request<API.AlipayFundTransPagePayResponse>('/api/Alipay/AlipayRecharge', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取用户签约页面地址 GET /api/Alipay/GetUserAgreementPageSign */
export async function getUserAgreementPageSign(options?: API.RequestConfig) {
  return request<string>('/api/Alipay/GetUserAgreementPageSign', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取支付宝开户状态 GET /api/Alipay/UserAgreementQuery */
export async function userAgreementQuery(options?: API.RequestConfig) {
  return request<number>('/api/Alipay/UserAgreementQuery', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 支付宝个人代扣协议解约接口 GET /api/Alipay/UserAgreementUnsign */
export async function userAgreementUnsign(options?: API.RequestConfig) {
  return request<number>('/api/Alipay/UserAgreementUnsign', {
    method: 'GET',
    ...(options || {}),
  });
}

 src/services/api/AlipayEcsignNotify.ts

New file
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 信任签异步通知 POST /api/AlipayEcsignNotify/SignorderNotify */
export async function signorderNotify(
  body: API.AlipayEcsignNotifyInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/AlipayEcsignNotify/SignorderNotify', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Area.ts

New file
@@ -0,0 +1,39 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 资讯管理--适用区域 GET /api/Area/GetApplicableAreaList */
export async function getApplicableAreaList(options?: API.RequestConfig) {
  return request<API.AreaDto[]>('/api/Area/GetApplicableAreaList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取省市区 GET /api/Area/GetAreaList */
export async function getAreaList(options?: API.RequestConfig) {
  return request<API.AreaDto[]>('/api/Area/GetAreaList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取区域列表（省、市、区） POST /api/Area/GetAreas */
export async function getAreas(body: API.GetAreaListInput, options?: API.RequestConfig) {
  return request<API.AreaDto[]>('/api/Area/GetAreas', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 搜索管理--列表(区域管理) GET /api/Area/GetRegionalManagementList */
export async function getRegionalManagementList(options?: API.RequestConfig) {
  return request<API.AreaInfo[]>('/api/Area/GetRegionalManagementList', {
    method: 'GET',
    ...(options || {}),
  });
}

 src/services/api/BestSign.ts

New file
@@ -0,0 +1,1736 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 检查订单双方是否已对该订单发起过签约 false 已存在 true不存在 POST /api/BestSign/CheckOrderSignExsit */
export async function checkOrderSignExsit(
  body: API.CheckOrderSignInput,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/BestSign/CheckOrderSignExsit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 下载上上签证据报告 POST /api/BestSign/ContractEvidenceReportDownload */
export async function contractEvidenceReportDownload(
  body: API.ContractEvidenceReportDownloadInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/BestSign/ContractEvidenceReportDownload', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取H5刷脸签署的订单号
因签署接口没有直接返回刷脸的orderNo，故通过此接口获取刷脸签署通过后产生的orderNo，通过此orderNo可以下载刷脸签署时的视频或照片文件。 POST /api/BestSign/ContractGetFaceAuthOrderNo */
export async function contractGetFaceAuthOrderNo(
  body: API.ContractGetFaceAuthOrderNoInput,
  options?: API.RequestConfig
) {
  return request<API.SingleSearchKeyInputBestSignOutputBase>(
    '/api/BestSign/ContractGetFaceAuthOrderNo',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 合同签约，返回签约链接 POST /api/BestSign/ContractSendByTemplate */
export async function contractSendByTemplate(
  body: API.ContractSendByTemplateInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/ContractSendByTemplate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 自动创建付款信息 GET /api/BestSign/CreateBusinessPayData */
export async function createBusinessPayData(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIcreateBusinessPayDataParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/BestSign/CreateBusinessPayData', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 企业三要素验证 验证企业“企业名称、工商注册号或统一社会信用代码、法定代表人姓名”三要素之间的一致性。仅中国大陆的企业能够验证。此接口按照调用次数单独计费。
注：因工商总局数据源限制，使用个体工商户信息校验时会有较大概率返回“查询无结果”，此时开发者可至公开的企业征信类网站（比如企查查、天眼查等网站）手动查询对比。
民办企业、事业单位等非工商企业，不支持用企业工商接口查询和核验。 POST /api/BestSign/CredentialVerifyEnterpriseIdentity3 */
export async function credentialVerifyEnterpriseIdentity3(
  body: API.CredentialVerifyEnterpriseIdInput,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyEnterpriseIdResponseBestSignOutputBase>(
    '/api/BestSign/CredentialVerifyEnterpriseIdentity3',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 企业四要素验证
验证企业“企业名称、工商注册号或统一社会信用代码、法定代表人姓名、法定代表人身份证号”四要素之间的一致性。此接口按照调用次数单独计费。
注：1、因工商总局数据源限制，使用个体工商户信息校验时会有较大概率返回“查询无结果”，此时开发者可至公开的企业征信类网站（比如企查查、天眼查等网站）手动查询对比。
2、民办企业、事业单位等非工商企业，不支持用企业工商接口查询和核验。
3、企业四要素中未包含企业经营状态，如需核验企业经营状态请使用接口“查询企业工商信息”。 POST /api/BestSign/CredentialVerifyEnterpriseIdentity4 */
export async function credentialVerifyEnterpriseIdentity4(
  body: API.CredentialVerifyEnterpriseIdInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>(
    '/api/BestSign/CredentialVerifyEnterpriseIdentity4',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 企业打款状态查询
此接口用于查询认证企业发起的打款请求的到账情况。 POST /api/BestSign/CredentialVerifyEnterprisePayAuth */
export async function credentialVerifyEnterprisePayAuth(
  body: API.CredentialVerifyEnterprisePayAuthInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/CredentialVerifyEnterprisePayAuth', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 企业应答验证
此接口用于“企业将对公账户收到的最新一笔有效的小于1元的随机金额回填至系统”，校验实名认证结果。
回答次数限制：6次，达到6次错误则随机金额失效，需重新打款。 POST /api/BestSign/CredentialVerifyEnterprisePayAuthVerify */
export async function credentialVerifyEnterprisePayAuthVerify(
  body: API.CredentialVerifyEnterprisePayAuthVerifyInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>(
    '/api/BestSign/CredentialVerifyEnterprisePayAuthVerify',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取刷脸认证/签署的视频或照片
获取刷脸校验通过后的视频或照片。
支持范围：支持腾讯云H5刷脸、腾讯SDK刷脸、腾讯小程序刷脸方式；支付宝刷脸方式因支付宝的安全策略限制照片无法获取。
时效性：目前腾讯云对刷脸视频或照片文件最多保存三天，故如需获取请在刷脸后的三天内获取。。 POST /api/BestSign/CredentialVerifyFaceAuthResultDownload */
export async function credentialVerifyFaceAuthResultDownload(
  body: API.CredentialVerifyFaceAuthResultDownloadInput,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyFaceAuthResultDownloadResponseBestSignOutputBase>(
    '/api/BestSign/CredentialVerifyFaceAuthResultDownload',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 个人银行卡二要素验证 对个人姓名与银行卡号进行二要素比对验证，比如在人事发工资场景中，可以用此接口校验银行卡与新员工是否匹配，防止发错工资卡。此接口按照调用次数单独计费。 POST /api/BestSign/CredentialVerifyPersonalBankcard2 */
export async function credentialVerifyPersonalBankcard2(
  body: API.CredentialVerifyPersonalBankcard2Input,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyPersonalIdentity2ResponseBestSignOutputBase>(
    '/api/BestSign/CredentialVerifyPersonalBankcard2',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 个人二要素验证 验证个人“姓名、身份证号”二要素之间的一致性。此接口按照调用次数单独计费。 POST /api/BestSign/CredentialVerifyPersonalIdentity2 */
export async function credentialVerifyPersonalIdentity2(
  body: API.CredentialVerifyPersonalIdentity2Input,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyPersonalIdentity2ResponseBestSignOutputBase>(
    '/api/BestSign/CredentialVerifyPersonalIdentity2',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 非大陆身份信息二要素
用于非中国大陆居民身份证类型的身份二要素核验。
本接口通过出入境管理局的数据源核验，仅支持港澳台等非大陆身份证的身份信息，若核验结果不符合使用预期（比如中国公民护照有过出境旅游的记录核验结果可能会出现”文本信息比对一致但中国公民护照查询无结果”的情况），请改用其他的核验方式。
本接口按照调用次数单独计费。 POST /api/BestSign/CredentialVerifyPersonalIdentity3Abroad */
export async function credentialVerifyPersonalIdentity3Abroad(
  body: API.CredentialVerifyPersonalId3AbroadInput,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyEnterpriseIdResponseBestSignOutputBase>(
    '/api/BestSign/CredentialVerifyPersonalIdentity3Abroad',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 个人手机号三要素验证 验证个人“姓名、身份证号、手机号码”三要素之间的一致性。手机号码为三大运营商手机号码。此接口按照调用次数单独计费。 POST /api/BestSign/CredentialVerifyPersonalIdentity3Mobile */
export async function credentialVerifyPersonalIdentity3Mobile(
  body: API.CredentialVerifyPersonalIdentity2Input,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>(
    '/api/BestSign/CredentialVerifyPersonalIdentity3Mobile',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 个人银行卡多要素验证 验证个人“姓名、身份证号、银行卡号、银行卡预留手机号码”多要素之间的一致性。此接口按照调用次数单独计费。 POST /api/BestSign/CredentialVerifyPersonalIdentity4 */
export async function credentialVerifyPersonalIdentity4(
  body: API.CredentialVerifyPersonalBankcard2Input,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyPersonalIdentity2ResponseBestSignOutputBase>(
    '/api/BestSign/CredentialVerifyPersonalIdentity4',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 下载签约存证报告 POST /api/BestSign/DistContractDownloadSignProcessReport */
export async function distContractDownloadSignProcessReport(
  body: API.GetUserStorageContractUploadResponse,
  options?: API.RequestConfig
) {
  return request<string>('/api/BestSign/DistContractDownloadSignProcessReport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上传模版变量创建合同,通过模版创建一个pdf文件，并设置template values到模板文件最终生成合同编号。这个接口将原来的template/createContractPdf和contract/createByTemplate这两个接口二合一使用。 POST /api/BestSign/DistTemplateCreateContract */
export async function distTemplateCreateContract(
  body: API.DistTemplateCreateContractInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/DistTemplateCreateContract', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 连续执行 客户注册 认证流程 POST /api/BestSign/EnterpriseRegVerify */
export async function enterpriseRegVerify(
  body: API.EnterpriseRegVerifyInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/EnterpriseRegVerify', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 注册企业用户并申请证书 POST /api/BestSign/EnterpriseUserReg */
export async function enterpriseUserReg(
  body: API.EnterpriseUserRegInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/EnterpriseUserReg', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询批量发放明细 POST /api/BestSign/GetBatchSettlePayInfoList */
export async function getBatchSettlePayInfoList(
  body: API.GetBusinessPayInfoInput,
  options?: API.RequestConfig
) {
  return request<API.GetBusinessPayInfoOutputPageOutput>(
    '/api/BestSign/GetBatchSettlePayInfoList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取协议文件预览路径 GET /api/BestSign/GetContactFilePreviewUrl */
export async function getContactFilePreviewUrl(options?: API.RequestConfig) {
  return request<string>('/api/BestSign/GetContactFilePreviewUrl', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取订单协议中支付信息列表 GET /api/BestSign/GetOrderBusinessPayList */
export async function getOrderBusinessPayList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOrderBusinessPayListParams,
  options?: API.RequestConfig
) {
  return request<API.GetSignOrderToPayDto[]>('/api/BestSign/GetOrderBusinessPayList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取订单签约协议详细信息 GET /api/BestSign/GetSignContractToOrderDto */
export async function getSignContractToOrderDto(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetSignContractToOrderDtoParams,
  options?: API.RequestConfig
) {
  return request<API.GetSignContractToOrderOutput>('/api/BestSign/GetSignContractToOrderDto', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查询协议管理 POST /api/BestSign/GetSignContractToOrderList */
export async function getSignContractToOrderList(
  body: API.GetSignContractToOrderInput,
  options?: API.RequestConfig
) {
  return request<API.GetSignContractToOrderOutputPageOutput>(
    '/api/BestSign/GetSignContractToOrderList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取电子签收款账户信息 GET /api/BestSign/GetSignEnterToBankInfo */
export async function getSignEnterToBankInfo(options?: API.RequestConfig) {
  return request<API.BestSignEnterBankInfoDto>('/api/BestSign/GetSignEnterToBankInfo', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取付款/收款管理列表 POST /api/BestSign/GetSignOrderPayList */
export async function getSignOrderPayList(
  body: API.GetOrderSignPayInput,
  options?: API.RequestConfig
) {
  return request<API.GetSignContractToOrderOutputPageOutput>('/api/BestSign/GetSignOrderPayList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取用户申请证书状态 GET /api/BestSign/GetUserCertApplyStatus */
export async function getUserCertApplyStatus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserCertApplyStatusParams,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/GetUserCertApplyStatus', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 回去订单合同列表 POST /api/BestSign/GetUserOrderContactList */
export async function getUserOrderContactList(
  body: API.GetOrderContractInput,
  options?: API.RequestConfig
) {
  return request<API.GetOrderContractInfoPageOutput>('/api/BestSign/GetUserOrderContactList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 运营后台获取交易管理列表 POST /api/BestSign/GetUserOrderSignPayList */
export async function getUserOrderSignPayList(
  body: API.GetUserOrderSignPayListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSignContractToOrderOutputPageOutput>(
    '/api/BestSign/GetUserOrderSignPayList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 上传发票或费用明细文件 POST /api/BestSign/OrderSinglePayUploadFile */
export async function orderSinglePayUploadFile(
  body: API.OrderSinglePayUploadFileInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/BestSign/OrderSinglePayUploadFile', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 发票确认 POST /api/BestSign/OrderSinglePayVerifyInvoice */
export async function orderSinglePayVerifyInvoice(
  body: API.OrderSinglePayVerifyInvoiceInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/BestSign/OrderSinglePayVerifyInvoice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 个人人脸比对验证 POST /api/BestSign/PersonalIdentity3Face */
export async function personalIdentity3Face(
  body: API.PersonalIdentity3FaceInput,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyPersonalIdentity2ResponseBestSignOutputBase>(
    '/api/BestSign/PersonalIdentity3Face',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 注册个人用户并申请证书 POST /api/BestSign/PersonalUserReg */
export async function personalUserReg(body: API.PersonalUserRegInput, options?: API.RequestConfig) {
  return request<API.BestSignRegDataResponseBestSignOutputBase>('/api/BestSign/PersonalUserReg', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 企业银行打款（关联用户）
此接口用于 “向企业对公账户转账一笔小于1元的随机金额”，到账时间1-2个工作日。（暂不支持国外、港澳台、北屯、双河、可克达拉、昆玉、东沙群岛等地区的对公打款认证）
注：1、此接口按照调用次数单独计费，如需调用本接口请先向上上签申请，开通后方可使用。
2、 随机金额每天（24h内）最多允许获取5次，重新发起即要求上一笔金额失效。
3、 随机金额用于回填验证，有效期是5天
4、 在向财务核对到账情况时，打款方是“通联支付网络服务股份有限公司”或“杭州尚尚签网络科技有限公司”二者中的一个。
5、 在向财务核对到账情况时，到账附言栏显示：上上签企业打款。
6、 部分银行对公打款业务不支持或者打款有延迟。如遇到打款问题，请咨询客服热线：400-993-6665。
7、“联行号”字段为非必填项，默认可不传，但有些银行有可能会打款不成功，此时需要带上联行号重试。联行号可参考微信支付https://pay.weixin.qq.com/wiki/doc/api/xiaowei.php?chapter=22_1 的《开户银行全称（含支行）对照表 》。
本接口已与account关联，支持在电子签约存证报告中体现此核验结果（电子签约存证报告需通过account将签署信息与实名认证核验信息关联起来），用于替代原先无存证的方式/credentialVerify/enterprise/payAuth。 POST /api/BestSign/RealNameEnterpriseCorporateAccountAudit */
export async function realNameEnterpriseCorporateAccountAudit(
  body: API.RealNameEnterpriseCorporateAccountAuditInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>(
    '/api/BestSign/RealNameEnterpriseCorporateAccountAudit',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 查询企业工商信息，通过统一社会信用代码查询企业工商信息。此接口按照调用次数单独计费。 POST /api/BestSign/RealNameEnterpriseIndustryCommerceInfo */
export async function realNameEnterpriseIndustryCommerceInfo(
  body: API.SingleSearchKeyInput,
  options?: API.RequestConfig
) {
  return request<API.RealNameEnterpriseIndustryCommerceInfoResponseBestSignOutputBase>(
    '/api/BestSign/RealNameEnterpriseIndustryCommerceInfo',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 企业银行反向打款认证 该接口用于企业认证，使用该接口请注意：1.请使用认证方企业对公银行账户提前向指定银行账户打款，接收方银行账户信息如下：
2.打款金额为0.01元人民币，不接受其他币种以及其他金额，且打款金额不退回；
3.实际打款到账时间会有延迟，请在打款15-30分钟后再调用该接口进行查询； POST /api/BestSign/RealNameEnterpriseRemitInfoAudit */
export async function realNameEnterpriseRemitInfoAudit(
  body: API.RealNameEnterpriseRemitInfoAuditInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/RealNameEnterpriseRemitInfoAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 请求认证url POST /api/BestSign/RealNamePersonalIdentity2AlipayFace */
export async function realNamePersonalIdentity2AlipayFace(
  body: API.RealNamePersonalIdentity2FaceInput,
  options?: API.RequestConfig
) {
  return request<API.RealNamePersonalIdentity2FaceResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity2AlipayFace',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 请求认证url POST /api/BestSign/RealNamePersonalIdentity2BestSignFace */
export async function realNamePersonalIdentity2BestSignFace(
  body: API.RealNamePersonalIdentity2FaceInput,
  options?: API.RequestConfig
) {
  return request<API.RealNamePersonalIdentity2FaceResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity2BestSignFace',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 请求认证url
利用个人“接口账号、姓名、身份证号等”要素生成唯一的认证url地址，通过该url地址跳转到腾讯云的H5认证页面。此接口单独计费。
此接口支持港澳台居民在大陆办理的港澳台居住证。
注：在小程序环境中打开长链接，请做好Encode与Decode，以此确保链接完整性，否则容易参数出错导致刷脸链接无法在小程序中打开。
链接有效期2分钟。
App兼容性请参考腾讯云文档 https://cloud.tencent.com/document/product/1007/61076 （外部文档，如失效请直接搜索“兼容性配置指引”） POST /api/BestSign/RealNamePersonalIdentity2Face */
export async function realNamePersonalIdentity2Face(
  body: API.RealNamePersonalIdentity2FaceInput,
  options?: API.RequestConfig
) {
  return request<API.RealNamePersonalIdentity2FaceResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity2Face',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 认证结果回调通知 POST /api/BestSign/RealNamePersonalIdentity2FaceCallBack */
export async function realNamePersonalIdentity2FaceCallBack(
  body: API.RealNamePersonalId2FaceCallBackRequest,
  options?: API.RequestConfig
) {
  return request<number>('/api/BestSign/RealNamePersonalIdentity2FaceCallBack', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取刷脸结果
获取刷脸结果，支持腾讯云（即微众）刷脸、阿里云刷脸、支付宝（即蚂蚁）刷脸以及其他刷脸。 POST /api/BestSign/RealNamePersonalIdentity2GetFaceAuthResult */
export async function realNamePersonalIdentity2GetFaceAuthResult(
  body: API.SingleSearchKeyInput,
  options?: API.RequestConfig
) {
  return request<API.RealNamePersonalIdentity2GetFaceAuthResultResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity2GetFaceAuthResult',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 个人手机号三要素验证码获取
此接口用于个人用户姓名、身份证、手机号3要素收集校验, 以及验证码的发送。该接口需与“个人手机号三要素验证码校验”接口搭配使用。获取到的验证码有效期为3分钟，用于校验的personalIdentity3Key为永久有效，但重新获取验证码后需要使用新personalIdentity3Key。
此接口按照调用次数单独计费，请确认已购买并开通此接口权限。 POST /api/BestSign/RealNamePersonalIdentity3VcodeSender */
export async function realNamePersonalIdentity3VcodeSender(
  body: API.RealNamePersonalIdentity3VcodeSenderInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>(
    '/api/BestSign/RealNamePersonalIdentity3VcodeSender',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 个人手机号三要素验证码校验
此接口用于个人用户姓名、身份证、手机号3要素收集校验, 以及验证码的发送。该接口需与“个人手机号三要素验证码校验”接口搭配使用。获取到的验证码有效期为3分钟，用于校验的personalIdentity3Key为永久有效，但重新获取验证码后需要使用新personalIdentity3Key。
此接口按照调用次数单独计费，请确认已购买并开通此接口权限。 POST /api/BestSign/RealNamePersonalIdentity3VcodeVerify */
export async function realNamePersonalIdentity3VcodeVerify(
  body: API.RealNamePersonalIdentity3VcodeSenderResponse,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>(
    '/api/BestSign/RealNamePersonalIdentity3VcodeVerify',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 银行卡多要素校验及发送验证码（支持非身份证）
此接口用于个人用户姓名、非身份证件类型的证件号码、银行卡号、银行卡预留手机号4要素校验, 校验通过后向该手机号发送短信验证码。该接口需与接口“银行卡多要素验证码校验（支持非身份证）”联合使用。获取到的验证码有效期为3分钟，用于校验的personalIdentity4PlusKey为永久有效，但重新获取验证码后需要使用新personalIdentity4PlusKey。此接口按照调用次数单独计费，请确认已购买并开通此接口权限。
注：
1.个人用户需要持有用当前校验证件办理的大陆的带银联标识的银行卡；
2.个人用户需要使用办理银行卡时预留的手机号码；
以上两条件，任一不满足，皆不可校验通过； POST /api/BestSign/RealNamePersonalIdentity4PlusVcodeSender */
export async function realNamePersonalIdentity4PlusVcodeSender(
  body: API.RealNamePersonalIdentity4VcodeVerifyInput,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyEnterpriseIdResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity4PlusVcodeSender',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 银行卡多要素验证码校验（支持非身份证）
此接口用于对接口“银行卡多要素校验及发送验证码（支持非身份证）”中的手机验证码进行校验。 POST /api/BestSign/RealNamePersonalIdentity4PlusVcodeVerify */
export async function realNamePersonalIdentity4PlusVcodeVerify(
  body: API.RealNamePersonalIdentity4PlusVcodeVerifyInput,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyEnterpriseIdResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity4PlusVcodeVerify',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 银行卡多要素校验及发送验证码
此接口用于个人用户姓名、身份证号、银行卡号、银行卡预留手机号4要素校验, 校验通过后向该手机号发送短信验证码。该接口需与接口“银行卡多要素验证码校验”联合使用。获取到的验证码有效期为3分钟，用于校验的personalIdentity4Key为永久有效，但重新获取验证码后需要使用新personalIdentity4Key。此接口按照调用次数单独计费，请确认已购买并开通此接口权限。 POST /api/BestSign/RealNamePersonalIdentity4VcodeSender */
export async function realNamePersonalIdentity4VcodeSender(
  body: API.RealNamePersonalIdentity3VcodeSenderInput,
  options?: API.RequestConfig
) {
  return request<API.RealNamePersonalIdentity4VcodeSenderResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity4VcodeSender',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 银行卡多要素校验及发送验证码
此接口用于个人用户姓名、身份证号、银行卡号、银行卡预留手机号4要素校验, 校验通过后向该手机号发送短信验证码。该接口需与接口“银行卡多要素验证码校验”联合使用。获取到的验证码有效期为3分钟，用于校验的personalIdentity4Key为永久有效，但重新获取验证码后需要使用新personalIdentity4Key。此接口按照调用次数单独计费，请确认已购买并开通此接口权限。 POST /api/BestSign/RealNamePersonalIdentity4VcodeVerify */
export async function realNamePersonalIdentity4VcodeVerify(
  body: API.RealNamePersonalIdentity4VcodeVerifyInput,
  options?: API.RequestConfig
) {
  return request<API.CredentialVerifyEnterpriseIdResponseBestSignOutputBase>(
    '/api/BestSign/RealNamePersonalIdentity4VcodeVerify',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 拒绝签约 POST /api/BestSign/RefundOrderContactSign */
export async function refundOrderContactSign(
  body: API.RefundOrderContactSignInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/BestSign/RefundOrderContactSign', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

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

/** 仅注册用户接口 POST /api/BestSign/SingleUserReg */
export async function singleUserReg(body: API.SingleUserRegInput, options?: API.RequestConfig) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/SingleUserReg', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 单用户注册测试 POST /api/BestSign/SingleUserRegTest */
export async function singleUserRegTest(body: API.SingleUserRegInput, options?: API.RequestConfig) {
  return request<number>('/api/BestSign/SingleUserRegTest', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取模版变量 POST /api/BestSign/TemplateGetTemplateVars */
export async function templateGetTemplateVars(
  body: API.UserTemplateGetTemplateVarsInput,
  options?: API.RequestConfig
) {
  return request<API.UserTemplateGetTemplateVarsResponseBestSignOutputBase>(
    '/api/BestSign/TemplateGetTemplateVars',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 此处后端没有提供注释 GET /api/BestSign/TestBestSign */
export async function testBestSign(options?: API.RequestConfig) {
  return request<number>('/api/BestSign/TestBestSign', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/BestSign/TestCallBack */
export async function testCallBack(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItestCallBackParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/BestSign/TestCallBack', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 乙方确认主体信息 POST /api/BestSign/ToVerifyOrderSignInfo */
export async function toVerifyOrderSignInfo(
  body: API.ToVerifyOrderSignInfoInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/ToVerifyOrderSignInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新合同签约状态 POST /api/BestSign/UpdateUserOrderContactStatus */
export async function updateUserOrderContactStatus(
  body: API.UpdateUserOrderContactStatusInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UpdateUserOrderContactStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** PDF文件验签（新） 上传PDF文件验证签名，返回PDF文件是否有证书签名、签名/文件在签名后是否有篡改，以及每个证书签名的具体信息 POST /api/BestSign/UserCertificationV2VerifySignatureByFile */
export async function userCertificationV2VerifySignatureByFile(
  body: API.UserDistTemplateUploadInput,
  options?: API.RequestConfig
) {
  return request<API.UserCertificationV2VerifySignatureByFileResponseListBestSignOutputBase>(
    '/api/BestSign/UserCertificationV2VerifySignatureByFile',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 撤销合同 POST /api/BestSign/UserContractCancel */
export async function userContractCancel(
  body: API.GetUserStorageContractUploadResponse,
  options?: API.RequestConfig
) {
  return request<API.BestSignDownloadImageDataResponseBestSignOutputBase>(
    '/api/BestSign/UserContractCancel',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 创建合同 POST /api/BestSign/UserContractCreate */
export async function userContractCreate(
  body: API.GetUserContractCreateInput,
  options?: API.RequestConfig
) {
  return request<API.GetUserStorageContractUploadResponseBestSignOutputBase>(
    '/api/BestSign/UserContractCreate',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 生成合同签约存证页文件 POST /api/BestSign/UserContractCreateAttachment */
export async function userContractCreateAttachment(
  body: API.UserContractCreateAttachmentInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserContractCreateAttachment', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 通过模版创建合同 POST /api/BestSign/UserContractCreateByTemplate */
export async function userContractCreateByTemplate(
  body: API.UserContractCreateByTemplateInput,
  options?: API.RequestConfig
) {
  return request<API.GetUserStorageContractUploadResponseBestSignOutputBase>(
    '/api/BestSign/UserContractCreateByTemplate',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 下载合同签约存证页文件 POST /api/BestSign/UserContractDownloadAttachment */
export async function userContractDownloadAttachment(
  body: API.UserContractCreateAttachmentInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserContractDownloadAttachment', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 企业手动签署（支持刷脸短信二选一） POST /api/BestSign/UserContractGetContractEnterpriseFaceSign */
export async function userContractGetContractEnterpriseFaceSign(
  body: API.UserGetContractEnterpriseFaceSignInput,
  options?: API.RequestConfig
) {
  return request<API.UserGetContractEnterpriseFaceSignResponseBestSignOutputBase>(
    '/api/BestSign/UserContractGetContractEnterpriseFaceSign',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 查询合同信息 POST /api/BestSign/UserContractGetInfo */
export async function userContractGetInfo(
  body: API.GetUserStorageContractUploadResponse,
  options?: API.RequestConfig
) {
  return request<API.GetUserContractGetInfoResponseBestSignOutputBase>(
    '/api/BestSign/UserContractGetInfo',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取预览合同URL POST /api/BestSign/UserContractGetPreview */
export async function userContractGetPreview(
  body: API.GetUserContractGetPreviewInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserContractGetPreview', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询合同签署者状态 POST /api/BestSign/UserContractGetSignerStatus */
export async function userContractGetSignerStatus(
  body: API.GetUserStorageContractUploadResponse,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserContractGetSignerStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取签署链接（即手动签） POST /api/BestSign/UserContractSend */
export async function userContractSend(
  body: API.UserGetContractSendInput,
  options?: API.RequestConfig
) {
  return request<API.GetUserContractGetPreviewResponseBestSignOutputBase>(
    '/api/BestSign/UserContractSend',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 发送签署验证码 向指定手机号发送指定合同的签署验证码，该验证码回填用于【带校验的自动签/storage/contract/sign/cert2/】接口做签署校验。本接口调用前需要先调用【设置合同签署参数】接口设置vcodeMobile参数，验证码默认有效期是三分钟，请在发送验证码的有效期之内回填验证码，如超过验证码有效期请重新发送。
注：同一手机号1分钟内只能有效获取一次验证码，请勿频繁发送以免被运营商误判为骚扰或短信轰炸。 POST /api/BestSign/UserContractSendSignVCode */
export async function userContractSendSignVCode(
  body: API.UserContractSendSignVCodeInput,
  options?: API.RequestConfig
) {
  return request<API.UserContractSendSignVCodeResponseBestSignOutputBase>(
    '/api/BestSign/UserContractSendSignVCode',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 自动签 POST /api/BestSign/UserContractSignCert */
export async function userContractSignCert(
  body: API.UserContractSignCertInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserContractSignCert', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 关键字定位签署合同 POST /api/BestSign/UserContractSignKeywords */
export async function userContractSignKeywords(
  body: API.UserContractSignKeywordsInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserContractSignKeywords', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用模版变量签署合同 POST /api/BestSign/UserContractSignTemplate */
export async function userContractSignTemplate(
  body: API.UserContractSignTemplateInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserContractSignTemplate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 生成用户签名/印章图片 POST /api/BestSign/UserCreateSignatureImage */
export async function userCreateSignatureImage(
  body: API.GetUserCreateSignatureImageInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserCreateSignatureImage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 身份证OCR识别 识别身份证正反面信息。此接口按照调用次数单独计费 POST /api/BestSign/UserCredentialVerifyOcrIDCard */
export async function userCredentialVerifyOcrIDCard(
  body: API.UserCredentialVerifyOcrIDCardInput,
  options?: API.RequestConfig
) {
  return request<API.UserCredentialVerifyOcrIDCardResponseBestSignOutputBase>(
    '/api/BestSign/UserCredentialVerifyOcrIDCard',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 生成企业印章图片 POST /api/BestSign/UserDistCreateSignatureEnt */
export async function userDistCreateSignatureEnt(
  body: API.GetUserCreateSignatureEntInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserDistCreateSignatureEnt', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上传PDF文件并创建模版 POST /api/BestSign/UserDistTemplateUpload */
export async function userDistTemplateUpload(
  body: API.UserDistTemplateUploadInput,
  options?: API.RequestConfig
) {
  return request<API.UserTemplateGetTemplateVarsInputBestSignOutputBase>(
    '/api/BestSign/UserDistTemplateUpload',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 下载用户签名/印章图片 POST /api/BestSign/UserDownloadSignatureImage */
export async function userDownloadSignatureImage(
  body: API.GetUserUploadSignatureImageInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/BestSign/UserDownloadSignatureImage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取文件meta信息 POST /api/BestSign/UserFileMetaSDK */
export async function userFileMetaSDK(body: API.GetFileMetaSDKInput, options?: API.RequestConfig) {
  return request<API.GetUserFileMetaSDKDataResponseBestSignOutputBase>(
    '/api/BestSign/UserFileMetaSDK',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 甲方发起签约确认邀约 POST /api/BestSign/UserFromSendSignInvite */
export async function userFromSendSignInvite(
  body: API.DistTemplateCreateContractInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserFromSendSignInvite', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 异步申请状态查询 POST /api/BestSign/UserGetApplyCertStatus */
export async function userGetApplyCertStatus(
  body: API.GetAsyncapplyCertStatusInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserGetApplyCertStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户基本信息查询 POST /api/BestSign/UserGetBaseInfo */
export async function userGetBaseInfo(body: API.GetCertDataInput, options?: API.RequestConfig) {
  return request<API.GetUserBaseInfoDataResponseBestSignOutputBase>(
    '/api/BestSign/UserGetBaseInfo',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 查询证书编号 POST /api/BestSign/UserGetCert */
export async function userGetCert(body: API.GetCertDataInput, options?: API.RequestConfig) {
  return request<API.GetCertDataResponseBestSignOutputBase>('/api/BestSign/UserGetCert', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取证书详细信息 POST /api/BestSign/UserGetCertInfo */
export async function userGetCertInfo(body: API.GetCertDataResponse, options?: API.RequestConfig) {
  return request<API.GetUserCertInfoDataResponseBestSignOutputBase>(
    '/api/BestSign/UserGetCertInfo',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 查询企业用户证件信息 POST /api/BestSign/UserGetEnterpriseCredential */
export async function userGetEnterpriseCredential(
  body: API.GetCertDataInput,
  options?: API.RequestConfig
) {
  return request<API.GetEnterpriseCredentialDataResponseBestSignOutputBase>(
    '/api/BestSign/UserGetEnterpriseCredential',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 查询个人用户证件信息 POST /api/BestSign/UserGetPersonalCredential */
export async function userGetPersonalCredential(
  body: API.GetCertDataInput,
  options?: API.RequestConfig
) {
  return request<API.GetPersonalCredentialDataResponseBestSignOutputBase>(
    '/api/BestSign/UserGetPersonalCredential',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 发送多文档自动签验证码 与“带短信校验的多文档自动签/dist/catalog/sign/cert/”搭配使用。
注：同一手机号1分钟内只能有效获取一次验证码，请勿频繁发送以免被运营商误判为骚扰或短信轰炸。 POST /api/BestSign/UserNoticeSendSignVCode */
export async function userNoticeSendSignVCode(
  body: API.UserNoticeSendSignVCodeInput,
  options?: API.RequestConfig
) {
  return request<API.UserContractSendSignVCodeResponseBestSignOutputBase>(
    '/api/BestSign/UserNoticeSendSignVCode',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取创建模版的地址 POST /api/BestSign/UserPageTemplateCreate */
export async function userPageTemplateCreate(
  body: API.UserPageTemplateCreateInput,
  options?: API.RequestConfig
) {
  return request<API.GetUserContractGetPreviewResponseBestSignOutputBase>(
    '/api/BestSign/UserPageTemplateCreate',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 预览模版 POST /api/BestSign/UserPageTemplatePreview */
export async function userPageTemplatePreview(
  body: API.UserPageTemplatePreviewInput,
  options?: API.RequestConfig
) {
  return request<API.GetUserContractGetPreviewResponseBestSignOutputBase>(
    '/api/BestSign/UserPageTemplatePreview',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 验证码发送接口 POST /api/BestSign/UserPersonalRealNameSendVCode */
export async function userPersonalRealNameSendVCode(
  body: API.UserPersonalRealNameSendVCodeInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserPersonalRealNameSendVCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 验证码发送接口 POST /api/BestSign/UserPersonalRegAndRealNameAndApplyCert */
export async function userPersonalRegAndRealNameAndApplyCert(
  body: API.UserPersonalRegAndRealNameAndApplyCertInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>(
    '/api/BestSign/UserPersonalRegAndRealNameAndApplyCert',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 重新申请数字证书 POST /api/BestSign/UserReApplyCert */
export async function userReApplyCert(body: API.GetCertDataInput, options?: API.RequestConfig) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserReApplyCert', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 为PDF文件添加元素 POST /api/BestSign/UserStorageAddPdfElements */
export async function userStorageAddPdfElements(
  body: API.GetUserStorageaddPdfElementsInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignStorageUploadDataResponseBestSignOutputBase>(
    '/api/BestSign/UserStorageAddPdfElements',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 下载合同文件 POST /api/BestSign/UserStorageContractDownload */
export async function userStorageContractDownload(
  body: API.GetUserStorageContractUploadResponse,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/BestSign/UserStorageContractDownload', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 锁定并结束合同 POST /api/BestSign/UserStorageContractLock */
export async function userStorageContractLock(
  body: API.GetUserStorageContractUploadResponse,
  options?: API.RequestConfig
) {
  return request<API.BestSignDownloadImageDataResponseBestSignOutputBase>(
    '/api/BestSign/UserStorageContractLock',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 带校验的自动签 不需要查看合同即可快捷完成签署。此接口要求签署者必须拥有自己的数字证书，提交手机号码（或邮箱）与短信验证码（或邮箱验证码），如验证码校验通过则完成签署，否则签署失败需重试。
使用此接口的流程为：“创建合同（/storage/contract/upload/或/contract/create/）——添加签署者（/contract/addSigner/或/contract/addSigners/）——设置合同签署参数（/contract/setSignerConfig/中设置vcodeMobile参数）——发送签署验证码（/contract/sendSignVCode/）——带校验的自动签（本接口）”。 POST /api/BestSign/UserStorageContractSignCert2 */
export async function userStorageContractSignCert2(
  body: API.UserContractSignCert2Input,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserStorageContractSignCert2', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上传并创建合同 POST /api/BestSign/UserStorageContractUpload */
export async function userStorageContractUpload(
  body: API.GetUserStorageContractUploadInput,
  options?: API.RequestConfig
) {
  return request<API.GetUserStorageContractUploadResponseBestSignOutputBase>(
    '/api/BestSign/UserStorageContractUpload',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 下载文件 POST /api/BestSign/UserStorageDownload */
export async function userStorageDownload(
  body: API.BestSignStorageUploadDataResponse,
  options?: API.RequestConfig
) {
  return request<string>('/api/BestSign/UserStorageDownload', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上传合同文件 POST /api/BestSign/UserStorageUpload */
export async function userStorageUpload(
  body: API.GetUserStorageUploadInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignStorageUploadDataResponseBestSignOutputBase>(
    '/api/BestSign/UserStorageUpload',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 通过模版生成合同文件 POST /api/BestSign/UserTemplateCreateContractPdf */
export async function userTemplateCreateContractPdf(
  body: API.UserTemplateCreateContractPdfInput,
  options?: API.RequestConfig
) {
  return request<API.UserTemplateCreateContractPdfResponseBestSignOutputBase>(
    '/api/BestSign/UserTemplateCreateContractPdf',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 删除模版 POST /api/BestSign/UserTemplateDelete */
export async function userTemplateDelete(
  body: API.UseDeleteTemplateInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignOutputDynamic>('/api/BestSign/UserTemplateDelete', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取模板详情 POST /api/BestSign/UserTemplateGetTemplateDetail */
export async function userTemplateGetTemplateDetail(
  body: API.GetTemplateInfoInput,
  options?: API.RequestConfig
) {
  return request<API.GetTemplateVarsSubNodeTemplateDto>(
    '/api/BestSign/UserTemplateGetTemplateDetail',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 上传用户签名/印章图片 POST /api/BestSign/UserUploadSignatureImage */
export async function userUploadSignatureImage(
  body: API.GetUserUploadSignatureImageInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRegDataResponseBestSignOutputBase>(
    '/api/BestSign/UserUploadSignatureImage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 人脸照片自带比对源比对，比对两张人脸照片的相似度。此接口按照调用次数单独计费。 POST /api/BestSign/WebankDoFaceCompare */
export async function webankDoFaceCompare(
  body: API.WebankDoFaceCompareInput,
  options?: API.RequestConfig
) {
  return request<API.WebankDoFaceCompareResponseBestSignOutputBase>(
    '/api/BestSign/WebankDoFaceCompare',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取腾讯云刷脸认证结果 POST /api/BestSign/WebankGetFaceAuthResult */
export async function webankGetFaceAuthResult(
  body: API.SingleSearchKeyInput,
  options?: API.RequestConfig
) {
  return request<API.RealNamePersonalIdentity2GetFaceAuthResultResponseBestSignOutputBase>(
    '/api/BestSign/WebankGetFaceAuthResult',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 发送多文档自动签验证码 与“带短信校验的多文档自动签/dist/catalog/sign/cert/”搭配使用。
注：同一手机号1分钟内只能有效获取一次验证码，请勿频繁发送以免被运营商误判为骚扰或短信轰炸。 POST /api/BestSign/WebankGetFaceAuthSignIdcardFaceVerify */
export async function webankGetFaceAuthSignIdcardFaceVerify(
  body: API.WebankGetFaceAuthSignIdcardFaceVerifyInput,
  options?: API.RequestConfig
) {
  return request<API.WebankGetFaceAuthSignIdcardFaceVerifyResponseBestSignOutputBase>(
    '/api/BestSign/WebankGetFaceAuthSignIdcardFaceVerify',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 此处后端没有提供注释 GET /api/BestSign/WorkerBusinessPayMessageSend */
export async function workerBusinessPayMessageSend(options?: API.RequestConfig) {
  return request<number>('/api/BestSign/WorkerBusinessPayMessageSend', {
    method: 'GET',
    ...(options || {}),
  });
}

 src/services/api/BestSignCallBack.ts

New file
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 异步回调通知 POST /api/BestSignCallBack/SignCallBackNotice */
export async function signCallBackNotice(
  body: API.SignCallBackNoticeInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/BestSignCallBack/SignCallBackNotice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/CaiNiao.ts

New file
@@ -0,0 +1,120 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取入驻客户保险签约认证连接二维码 POST /api/CaiNiao/GetCompanyInsureSignQrCode */
export async function getCompanyInsureSignQrCode(
  body: API.GetInsureSignUrlInput,
  options?: API.RequestConfig
) {
  return request<API.GetCompanyInsureSignResult>('/api/CaiNiao/GetCompanyInsureSignQrCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询可投保的保险产品 POST /api/CaiNiao/GetInsureProductConsult */
export async function getInsureProductConsult(
  body: API.GetInsureProductConsultRequest,
  options?: API.RequestConfig
) {
  return request<API.GetInsureProductConsultResponse>('/api/CaiNiao/GetInsureProductConsult', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询投保产品单价 POST /api/CaiNiao/GetInsureProductPrice */
export async function getInsureProductPrice(
  body: API.GetInsureProductPriceInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsureProductPrice>('/api/CaiNiao/GetInsureProductPrice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询保险产品价格相关信息 POST /api/CaiNiao/GetInsureQueryUnitPrice */
export async function getInsureQueryUnitPrice(
  body: API.GetInsureQueryUnitPriceRequest,
  options?: API.RequestConfig
) {
  return request<API.GetInsureQueryUnitPriceResponse>('/api/CaiNiao/GetInsureQueryUnitPrice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 退保 POST /api/CaiNiao/GetInsureRefundSend */
export async function getInsureRefundSend(
  body: API.GetInsureRefundSendRequest,
  options?: API.RequestConfig
) {
  return request<API.GetInsureRefundSendResponse>('/api/CaiNiao/GetInsureRefundSend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户执行投保 POST /api/CaiNiao/GetInsureSend */
export async function getInsureSend(body: API.GetInsureSendRequest, options?: API.RequestConfig) {
  return request<API.GetInsureSendResponse>('/api/CaiNiao/GetInsureSend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取保险签约认证连接 POST /api/CaiNiao/GetInsureSignUrl */
export async function getInsureSignUrl(
  body: API.GetInsureSignUrlRequest,
  options?: API.RequestConfig
) {
  return request<API.GetInsureSignUrlResponse>('/api/CaiNiao/GetInsureSignUrl', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 插入投保产品信息 POST /api/CaiNiao/InsertInsureProductConsult */
export async function insertInsureProductConsult(
  body: API.GetInsureProductConsultRequest,
  options?: API.RequestConfig
) {
  return request<number>('/api/CaiNiao/InsertInsureProductConsult', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/CaiNiaoCallBack.ts

New file
@@ -0,0 +1,48 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 退保结果通知 POST /api/CaiNiaoCallBack/GetInsureRefundResultNotify */
export async function getInsureRefundResultNotify(options?: API.RequestConfig) {
  return request<API.GetInsureRefundResultNotifyResponse>(
    '/api/CaiNiaoCallBack/GetInsureRefundResultNotify',
    {
      method: 'POST',
      ...(options || {}),
    }
  );
}

/** 投保结果通知 POST /api/CaiNiaoCallBack/GetInsureResultNotify */
export async function getInsureResultNotify(options?: API.RequestConfig) {
  return request<API.GetInsureResultNotifyResponse>('/api/CaiNiaoCallBack/GetInsureResultNotify', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 投保结果通知 POST /api/CaiNiaoCallBack/GetInsureResultNotifyTest */
export async function getInsureResultNotifyTest(
  body: API.GetInsureResultNotifyRequest,
  options?: API.RequestConfig
) {
  return request<API.GetInsureResultNotifyResponse>(
    '/api/CaiNiaoCallBack/GetInsureResultNotifyTest',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 签约结果通知 POST /api/CaiNiaoCallBack/GetInsureSignNotify */
export async function getInsureSignNotify(options?: API.RequestConfig) {
  return request<API.GetInsureSignNotifyResponse>('/api/CaiNiaoCallBack/GetInsureSignNotify', {
    method: 'POST',
    ...(options || {}),
  });
}

 src/services/api/CircleFriend.ts

New file
@@ -0,0 +1,219 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 审核/关闭朋友圈消息 POST /api/CircleFriend/CheckCircleFriend */
export async function checkCircleFriend(
  body: API.CheckCircleFriendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CircleFriend/CheckCircleFriend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 审核朋友圈评论 POST /api/CircleFriend/CheckCircleFriendReply */
export async function checkCircleFriendReply(
  body: API.CheckCircleFriendReplyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CircleFriend/CheckCircleFriendReply', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 朋友圈消息删除 GET /api/CircleFriend/DeteleCircleFriend */
export async function deteleCircleFriend(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeteleCircleFriendParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/CircleFriend/DeteleCircleFriend', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除评论 GET /api/CircleFriend/DeteleCircleFriendReply */
export async function deteleCircleFriendReply(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeteleCircleFriendReplyParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/CircleFriend/DeteleCircleFriendReply', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取朋友圈消息 GET /api/CircleFriend/GetCircleFriend */
export async function getCircleFriend(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCircleFriendParams,
  options?: API.RequestConfig
) {
  return request<API.CircleFriendDto>('/api/CircleFriend/GetCircleFriend', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 朋友圈消息详情 GET /api/CircleFriend/GetCircleFriendDetail */
export async function getCircleFriendDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCircleFriendDetailParams,
  options?: API.RequestConfig
) {
  return request<API.CircleFriendDto>('/api/CircleFriend/GetCircleFriendDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 朋友圈消息列表 POST /api/CircleFriend/GetCircleFriendList */
export async function getCircleFriendList(
  body: API.GetCircleFriendListInput,
  options?: API.RequestConfig
) {
  return request<API.CircleFriendDtoPageOutput>('/api/CircleFriend/GetCircleFriendList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 朋友圈我关注的列表 POST /api/CircleFriend/GetCircleFriendMutualFollowList */
export async function getCircleFriendMutualFollowList(
  body: API.GetCircleFriendMutualFollowListInput,
  options?: API.RequestConfig
) {
  return request<API.CircleFriendDtoPageOutput>(
    '/api/CircleFriend/GetCircleFriendMutualFollowList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 评论详情 GET /api/CircleFriend/GetCircleFriendReply */
export async function getCircleFriendReply(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCircleFriendReplyParams,
  options?: API.RequestConfig
) {
  return request<API.CircleFriendReplyInfo>('/api/CircleFriend/GetCircleFriendReply', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取评论列表 POST /api/CircleFriend/GetCircleFriendReplyList */
export async function getCircleFriendReplyList(
  body: API.GetCircleFriendReplyListInput,
  options?: API.RequestConfig
) {
  return request<API.CircleFriendUserReplyPageOutput>(
    '/api/CircleFriend/GetCircleFriendReplyList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 发朋友圈 POST /api/CircleFriend/MakeACircleFriend */
export async function makeACircleFriend(
  body: API.MakeACircleFriendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CircleFriend/MakeACircleFriend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 朋友圈评论/回复 POST /api/CircleFriend/ReplyCircleFriend */
export async function replyCircleFriend(
  body: API.ReplyCircleFriendInput,
  options?: API.RequestConfig
) {
  return request<API.CircleFriendReplyInfo>('/api/CircleFriend/ReplyCircleFriend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 朋友圈取消点赞 POST /api/CircleFriend/ThumbsRecallCircleFriend */
export async function thumbsRecallCircleFriend(
  body: API.ThumbsCircleFriendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CircleFriend/ThumbsRecallCircleFriend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 朋友圈点赞 POST /api/CircleFriend/ThumbsUpCircleFriend */
export async function thumbsUpCircleFriend(
  body: API.ThumbsCircleFriendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CircleFriend/ThumbsUpCircleFriend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Common.ts

New file
@@ -0,0 +1,108 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取预览数据 GET /api/Common/GetPreViewCache */
export async function getPreViewCache(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPreViewCacheParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/Common/GetPreViewCache', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 第三方银行卡预留手机号验证 发送验证码 POST /api/Common/SendBankCardCertificationVerificationCode */
export async function sendBankCardCertificationVerificationCode(
  body: API.SendBankCardCertificationVerificationCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Common/SendBankCardCertificationVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 发送邮箱验证码 POST /api/Common/SendEmailVerificationCode */
export async function sendEmailVerificationCode(
  body: API.SendEmailVerificationCodeByBusinessTypeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Common/SendEmailVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 第三方手机号验证 发送验证码 POST /api/Common/SendPhoneCertificationVerificationCode */
export async function sendPhoneCertificationVerificationCode(
  body: API.SendPhoneCertificationVerificationCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Common/SendPhoneCertificationVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 发送验证码 POST /api/Common/SendVerificationCode */
export async function sendVerificationCode(
  body: API.SendPhoneVerificationCodeByBusinessTypeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Common/SendVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 写入预览数据 POST /api/Common/SetPreViewCache */
export async function setPreViewCache(body: API.SetPreViewCacheInput, options?: API.RequestConfig) {
  return request<string>('/api/Common/SetPreViewCache', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 身份证OCR识别 识别身份证正反面信息。此接口按照调用次数单独计费 POST /api/Common/UserCredentialVerifyOcrIDCard */
export async function userCredentialVerifyOcrIDCard(
  body: API.UserCredentialVerifyOcrIDCardInput,
  options?: API.RequestConfig
) {
  return request<API.UserCredentialVerifyOcrIDCardResponse>(
    '/api/Common/UserCredentialVerifyOcrIDCard',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/CompanyInsure.ts

New file
@@ -0,0 +1,206 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 入驻客户列表导出 POST /api/CompanyInsure/CompanyInsuresExport */
export async function companyInsuresExport(
  body: API.GetCompanyInsuresExportInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/CompanyInsure/CompanyInsuresExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增投保客户信息 POST /api/CompanyInsure/CreateCompanyInsure */
export async function createCompanyInsure(
  body: API.CreateCompanyInsureInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CompanyInsure/CreateCompanyInsure', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 甲方客户列表导出 POST /api/CompanyInsure/CustomerInfoExport */
export async function customerInfoExport(
  body: API.GetCustomerInfoExportInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/CompanyInsure/CustomerInfoExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取企业支付宝账号信息 GET /api/CompanyInsure/GetAlipayAccount */
export async function getAlipayAccount(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetAlipayAccountParams,
  options?: API.RequestConfig
) {
  return request<API.GetAlipayAccount>('/api/CompanyInsure/GetAlipayAccount', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取投保客户信息 GET /api/CompanyInsure/GetCompanyInsureById */
export async function getCompanyInsureById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCompanyInsureByIdParams,
  options?: API.RequestConfig
) {
  return request<API.CompanyInsureDto>('/api/CompanyInsure/GetCompanyInsureById', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 入驻客户列表 POST /api/CompanyInsure/GetCompanyInsurePagedList */
export async function getCompanyInsurePagedList(
  body: API.GetCompanyInsurePagedListInput,
  options?: API.RequestConfig
) {
  return request<API.CompanyInsureInfoPageOutput>('/api/CompanyInsure/GetCompanyInsurePagedList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 甲方客户信息列表 POST /api/CompanyInsure/GetCustomerInfoList */
export async function getCustomerInfoList(
  body: API.GetCustomerInfoListInput,
  options?: API.RequestConfig
) {
  return request<API.InsureCustomerInfoPageOutput>('/api/CompanyInsure/GetCustomerInfoList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 甲方客户列表 POST /api/CompanyInsure/GetInsureCustomers */
export async function getInsureCustomers(
  body: API.GetInsureCustomersInput,
  options?: API.RequestConfig
) {
  return request<API.InsureCustomerModelPageOutput>('/api/CompanyInsure/GetInsureCustomers', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取保险客户 GET /api/CompanyInsure/GetInsureCustomersForSelect */
export async function getInsureCustomersForSelect(options?: API.RequestConfig) {
  return request<API.InsureCustomerDto[]>('/api/CompanyInsure/GetInsureCustomersForSelect', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取签约结果 GET /api/CompanyInsure/GetInsureStatusInfo */
export async function getInsureStatusInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureStatusInfoParams,
  options?: API.RequestConfig
) {
  return request<API.GetInsureStatusInfo>('/api/CompanyInsure/GetInsureStatusInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据地址获取base64二维码 GET /api/CompanyInsure/GetQrCodeByUrl */
export async function getQrCodeByUrl(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetQrCodeByUrlParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/CompanyInsure/GetQrCodeByUrl', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 甲方客户列表导出 POST /api/CompanyInsure/InsureCustomersExport */
export async function insureCustomersExport(
  body: API.GetCustomersExportInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/CompanyInsure/InsureCustomersExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置企业支付宝账号 POST /api/CompanyInsure/SetAlipayAccount */
export async function setAlipayAccount(
  body: API.SetAlipayAccountInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CompanyInsure/SetAlipayAccount', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 编辑投保客户信息 POST /api/CompanyInsure/UpdateCompanyInsure */
export async function updateCompanyInsure(
  body: API.UpdateCompanyInsureInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CompanyInsure/UpdateCompanyInsure', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Consult.ts

New file
@@ -0,0 +1,179 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

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

/** 咨询信息收藏记录 POST /api/Consult/ConsultAttention */
export async function consultAttention(body: API.ConsultViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Consult/ConsultAttention', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 咨询信息浏览记录 POST /api/Consult/ConsultBrowse */
export async function consultBrowse(body: API.ConsultViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Consult/ConsultBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建咨询 POST /api/Consult/CreateOrEditConsult */
export async function createOrEditConsult(
  body: API.CreateOrEditConsultInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Consult/CreateOrEditConsult', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除咨询 GET /api/Consult/DeleteConsult */
export async function deleteConsult(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteConsultParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Consult/DeleteConsult', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取咨询详情 GET /api/Consult/GetConsultInfo */
export async function getConsultInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetConsultInfoParams,
  options?: API.RequestConfig
) {
  return request<API.ConsultDto>('/api/Consult/GetConsultInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 后端获取咨询列表 POST /api/Consult/GetConsultList */
export async function getConsultList(body: API.ConsultListInput, options?: API.RequestConfig) {
  return request<API.ConsultDtoPageOutput>('/api/Consult/GetConsultList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取推荐咨询 GET /api/Consult/GetConsultRecommend */
export async function getConsultRecommend(options?: API.RequestConfig) {
  return request<API.ConsultDto[]>('/api/Consult/GetConsultRecommend', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 前端获取咨询详情 GET /api/Consult/GetFronConsultInfo */
export async function getFronConsultInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFronConsultInfoParams,
  options?: API.RequestConfig
) {
  return request<API.ConsultDto>('/api/Consult/GetFronConsultInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 前端获取咨询列表 POST /api/Consult/GetFrontConsultList */
export async function getFrontConsultList(
  body: API.GetFrontConsultListInput,
  options?: API.RequestConfig
) {
  return request<API.ConsultDtoPageOutput>('/api/Consult/GetFrontConsultList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的咨询列表 POST /api/Consult/GetMyConsultList */
export async function getMyConsultList(
  body: API.GetMyConsultListInput,
  options?: API.RequestConfig
) {
  return request<API.ConsultDtoPageOutput>('/api/Consult/GetMyConsultList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置咨询状态 POST /api/Consult/SetConsultStatus */
export async function setConsultStatus(body: API.OrderStatusInput, options?: API.RequestConfig) {
  return request<number>('/api/Consult/SetConsultStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置推荐咨询 POST /api/Consult/SetResourceRecommend */
export async function setResourceRecommend(
  body: API.ConsultRecommendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Consult/SetResourceRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/CooperationApply.ts

New file
@@ -0,0 +1,96 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增合作的跟进 POST /api/CooperationApply/AddCooperationApplyFllow */
export async function addCooperationApplyFllow(
  body: API.CreateCooperationApplyFllowInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CooperationApply/AddCooperationApplyFllow', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增修改合作申请 POST /api/CooperationApply/CreateOrUpdateCooperationApply */
export async function createOrUpdateCooperationApply(
  body: API.CreateOrUpdateCooperationApplyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CooperationApply/CreateOrUpdateCooperationApply', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建平台合作 POST /api/CooperationApply/CreatePlatformCooperationApply */
export async function createPlatformCooperationApply(
  body: API.CreatePlatformCooperationApplyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CooperationApply/CreatePlatformCooperationApply', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取合作的详情 GET /api/CooperationApply/GetCooperationApplyById */
export async function getCooperationApplyById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCooperationApplyByIdParams,
  options?: API.RequestConfig
) {
  return request<API.CooperationApplyDto>('/api/CooperationApply/GetCooperationApplyById', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取合作的列表 POST /api/CooperationApply/GetCooperationApplyList */
export async function getCooperationApplyList(
  body: API.GetCooperationApplyInput,
  options?: API.RequestConfig
) {
  return request<API.CooperationApplyDtoPageOutput>(
    '/api/CooperationApply/GetCooperationApplyList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 设置合作状态 POST /api/CooperationApply/SetStatus */
export async function setStatus(
  body: API.SetCooperationApplyStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/CooperationApply/SetStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Customer.ts

New file
@@ -0,0 +1,93 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 批量设置客户服务人员 POST /api/Customer/BatchSetUserServiceStaff */
export async function batchSetUserServiceStaff(
  body: API.BatchSetUserServiceStaffInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Customer/BatchSetUserServiceStaff', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 客户管理分页列表 POST /api/Customer/GetCustomerManagePage */
export async function getCustomerManagePage(
  body: API.QueryCustomerManageInput,
  options?: API.RequestConfig
) {
  return request<API.CustomerManageListOutputPageOutput>('/api/Customer/GetCustomerManagePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 我的客户管理分页列表 POST /api/Customer/GetMyCustomerManagePage */
export async function getMyCustomerManagePage(
  body: API.QueryCustomerManageInput,
  options?: API.RequestConfig
) {
  return request<API.CustomerManageListOutputPageOutput>('/api/Customer/GetMyCustomerManagePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取服务人员分页列表 POST /api/Customer/GetServiceStaffPage */
export async function getServiceStaffPage(
  body: API.QueryServiceStaffListInput,
  options?: API.RequestConfig
) {
  return request<API.ServiceStaffListOutputPageOutput>('/api/Customer/GetServiceStaffPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置用户所属产业园区 POST /api/Customer/SetUserIndustrialPark */
export async function setUserIndustrialPark(
  body: API.SetUserIndustrialParkInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Customer/SetUserIndustrialPark', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置客户服务人员 POST /api/Customer/SetUserServiceStaff */
export async function setUserServiceStaff(
  body: API.SetUserServiceStaffInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Customer/SetUserServiceStaff', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/EnterpriseMaterial.ts

New file
@@ -0,0 +1,102 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增企业材料信息 POST /api/EnterpriseMaterial/AddEnterpriseMaterial */
export async function addEnterpriseMaterial(
  body: API.AddEnterpriseMaterialInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/EnterpriseMaterial/AddEnterpriseMaterial', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取企业材料信息详情 POST /api/EnterpriseMaterial/GetEnterpriseMaterialDetail */
export async function getEnterpriseMaterialDetail(
  body: API.QueryEnterpriseMaterialDetailInput,
  options?: API.RequestConfig
) {
  return request<API.EnterpriseMaterialDetailOutput>(
    '/api/EnterpriseMaterial/GetEnterpriseMaterialDetail',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 根据用户id和材料类型获取企业材料id GET /api/EnterpriseMaterial/GetEnterpriseMaterialIdByUserId */
export async function getEnterpriseMaterialIdByUserId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetEnterpriseMaterialIdByUserIdParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/EnterpriseMaterial/GetEnterpriseMaterialIdByUserId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取企业材料管理分页列表 POST /api/EnterpriseMaterial/GetEnterpriseMaterialManagePage */
export async function getEnterpriseMaterialManagePage(
  body: API.QueryEnterpriseMaterialManageListInput,
  options?: API.RequestConfig
) {
  return request<API.EnterpriseMaterialManageListOutputPageOutput>(
    '/api/EnterpriseMaterial/GetEnterpriseMaterialManagePage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取我的企业四流材料列表 POST /api/EnterpriseMaterial/GetMyEnterpriseMaterialPage */
export async function getMyEnterpriseMaterialPage(
  body: API.PageInput,
  options?: API.RequestConfig
) {
  return request<API.MyEnterpriseMaterialListOutputPageOutput>(
    '/api/EnterpriseMaterial/GetMyEnterpriseMaterialPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 更新企业材料信息 POST /api/EnterpriseMaterial/UpdateEnterpriseMaterial */
export async function updateEnterpriseMaterial(
  body: API.UpdateEnterpriseMaterialInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/EnterpriseMaterial/UpdateEnterpriseMaterial', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/FirstPartyCompany.ts

New file
@@ -0,0 +1,166 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增甲方企业企业信息 POST /api/FirstPartyCompany/AddFirstPartyCompany */
export async function addFirstPartyCompany(
  body: API.AddFirstPartyCompanyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/FirstPartyCompany/AddFirstPartyCompany', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增甲方企业审核信息 POST /api/FirstPartyCompany/AddFirstPartyCompanyAudit */
export async function addFirstPartyCompanyAudit(
  body: API.AddFirstPartyCompanyAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/FirstPartyCompany/AddFirstPartyCompanyAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取甲方企业审核详情 GET /api/FirstPartyCompany/GetFirstPartyCompanyAuditDatilById */
export async function getFirstPartyCompanyAuditDatilById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFirstPartyCompanyAuditDatilByIdParams,
  options?: API.RequestConfig
) {
  return request<API.FirstPartyCompanyAuditDatilOutput>(
    '/api/FirstPartyCompany/GetFirstPartyCompanyAuditDatilById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取甲方企业审核分页列表 POST /api/FirstPartyCompany/GetFirstPartyCompanyAuditPage */
export async function getFirstPartyCompanyAuditPage(
  body: API.QueryFirstPartyCompanyAuditListInput,
  options?: API.RequestConfig
) {
  return request<API.FirstPartyCompanyAuditListOutputPageOutput>(
    '/api/FirstPartyCompany/GetFirstPartyCompanyAuditPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取甲方企业企业信息详细 POST /api/FirstPartyCompany/GetFirstPartyCompanyDetail */
export async function getFirstPartyCompanyDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFirstPartyCompanyDetailParams,
  options?: API.RequestConfig
) {
  return request<API.FirstPartyCompanyDto>('/api/FirstPartyCompany/GetFirstPartyCompanyDetail', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取甲方企业分页列表 POST /api/FirstPartyCompany/GetFirstPartyCompanyListPage */
export async function getFirstPartyCompanyListPage(
  body: API.QueryFirstPartyCompanyListInput,
  options?: API.RequestConfig
) {
  return request<API.FirstPartyCompanyListOutputPageOutput>(
    '/api/FirstPartyCompany/GetFirstPartyCompanyListPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取甲方企业简单列表 GET /api/FirstPartyCompany/GetFirstPartyCompanySimpleList */
export async function getFirstPartyCompanySimpleList(options?: API.RequestConfig) {
  return request<API.EnterpriseSimpleOutput[]>(
    '/api/FirstPartyCompany/GetFirstPartyCompanySimpleList',
    {
      method: 'GET',
      ...(options || {}),
    }
  );
}

/** 获取我的甲方企业企业信息 POST /api/FirstPartyCompany/GetMyFirstPartyCompanyInfo */
export async function getMyFirstPartyCompanyInfo(options?: API.RequestConfig) {
  return request<API.MyFirstPartyCompanyDto>('/api/FirstPartyCompany/GetMyFirstPartyCompanyInfo', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 设置甲方企业审核状态 POST /api/FirstPartyCompany/SetFirstPartyCompanyAuditStatus */
export async function setFirstPartyCompanyAuditStatus(
  body: API.SetFirstPartyCompanyAuditStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/FirstPartyCompany/SetFirstPartyCompanyAuditStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新甲方企业企业信息 POST /api/FirstPartyCompany/UpdateFirstPartyCompany */
export async function updateFirstPartyCompany(
  body: API.UpdateFirstPartyCompanyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/FirstPartyCompany/UpdateFirstPartyCompany', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新甲方企业审核信息 POST /api/FirstPartyCompany/UpdateFirstPartyCompanyAudit */
export async function updateFirstPartyCompanyAudit(
  body: API.UpdateFirstPartyCompanyAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/FirstPartyCompany/UpdateFirstPartyCompanyAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Fund.ts

New file
@@ -0,0 +1,63 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取支付宝充值码信息 POST /api/Fund/GetAliRechargeCodeInfo */
export async function getAliRechargeCodeInfo(
  body: API.AliRechargeInput,
  options?: API.RequestConfig
) {
  return request<API.AliRechargeInfoAjaxResponse>('/api/Fund/GetAliRechargeCodeInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取支付宝充值状态 GET /api/Fund/GetAliRechargeStatus */
export async function getAliRechargeStatus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetAliRechargeStatusParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Fund/GetAliRechargeStatus', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取微信充值码信息 POST /api/Fund/GetWxRechargeCodeInfo */
export async function getWxRechargeCodeInfo(
  body: API.WxRechargeInput,
  options?: API.RequestConfig
) {
  return request<API.WxRechargeInfoAjaxResponse>('/api/Fund/GetWxRechargeCodeInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取微信充值状态 GET /api/Fund/GetWxRechargeStatus */
export async function getWxRechargeStatus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWxRechargeStatusParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Fund/GetWxRechargeStatus', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

 src/services/api/HeadHunter.ts

New file
@@ -0,0 +1,185 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

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

/** 创建猎头 POST /api/HeadHunter/CreateOrEditHunter */
export async function createOrEditHunter(
  body: API.CreateOrEditHeadHunterInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/HeadHunter/CreateOrEditHunter', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除猎头 GET /api/HeadHunter/DeleteHeadHunter */
export async function deleteHeadHunter(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteHeadHunterParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/HeadHunter/DeleteHeadHunter', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 前端获取猎头详情 GET /api/HeadHunter/GetFronHeadHunterInfo */
export async function getFronHeadHunterInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFronHeadHunterInfoParams,
  options?: API.RequestConfig
) {
  return request<API.HeadHunterDto>('/api/HeadHunter/GetFronHeadHunterInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 前端获取猎头列表 POST /api/HeadHunter/GetFrontHeadHunterList */
export async function getFrontHeadHunterList(
  body: API.GetFrontHeadHunterListInput,
  options?: API.RequestConfig
) {
  return request<API.HeadHunterDtoPageOutput>('/api/HeadHunter/GetFrontHeadHunterList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取猎头详情 GET /api/HeadHunter/GetHeadHunterInfo */
export async function getHeadHunterInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetHeadHunterInfoParams,
  options?: API.RequestConfig
) {
  return request<API.HeadHunterDto>('/api/HeadHunter/GetHeadHunterInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 后端获取猎头列表 POST /api/HeadHunter/GetHeadHunterList */
export async function getHeadHunterList(
  body: API.HeadHunterListInput,
  options?: API.RequestConfig
) {
  return request<API.HeadHunterDtoPageOutput>('/api/HeadHunter/GetHeadHunterList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取推荐猎头 GET /api/HeadHunter/GetHeadHunterRecommend */
export async function getHeadHunterRecommend(options?: API.RequestConfig) {
  return request<API.HeadHunterDto[]>('/api/HeadHunter/GetHeadHunterRecommend', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取我的猎头列表 POST /api/HeadHunter/GetMyHeadHunterList */
export async function getMyHeadHunterList(
  body: API.GetMyHeadHunterListInput,
  options?: API.RequestConfig
) {
  return request<API.HeadHunterDtoPageOutput>('/api/HeadHunter/GetMyHeadHunterList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 猎头信息收藏记录 POST /api/HeadHunter/HeadHunterAttention */
export async function headHunterAttention(
  body: API.HeadHunterViewInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/HeadHunter/HeadHunterAttention', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 猎头信息浏览记录 POST /api/HeadHunter/HeadHunterBrowse */
export async function headHunterBrowse(body: API.HeadHunterViewInput, options?: API.RequestConfig) {
  return request<number>('/api/HeadHunter/HeadHunterBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置猎头状态 POST /api/HeadHunter/SetHeadHunterStatus */
export async function setHeadHunterStatus(body: API.OrderStatusInput, options?: API.RequestConfig) {
  return request<number>('/api/HeadHunter/SetHeadHunterStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置推荐猎头 POST /api/HeadHunter/SetResourceRecommend */
export async function setResourceRecommend(
  body: API.HeadHunterRecommendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/HeadHunter/SetResourceRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/HelpQuestion.ts

New file
@@ -0,0 +1,93 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增修改帮助 POST /api/HelpQuestion/CreateOrEditHelpQuestion */
export async function createOrEditHelpQuestion(
  body: API.CreateOrEditHelpQuestionInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/HelpQuestion/CreateOrEditHelpQuestion', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除帮助 DELETE /api/HelpQuestion/DeleteHelpQuestion */
export async function deleteHelpQuestion(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteHelpQuestionParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/HelpQuestion/DeleteHelpQuestion', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

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

/** 获取帮助详情 GET /api/HelpQuestion/GetHelpQuestionInfo */
export async function getHelpQuestionInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetHelpQuestionInfoParams,
  options?: API.RequestConfig
) {
  return request<API.HelpQuestionDto>('/api/HelpQuestion/GetHelpQuestionInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取帮助详情列表 POST /api/HelpQuestion/GetHelpQuestionList */
export async function getHelpQuestionList(
  body: API.GetHelpQuestionListInput,
  options?: API.RequestConfig
) {
  return request<API.HelpQuestionDtoPageOutput>('/api/HelpQuestion/GetHelpQuestionList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置帮助状态 POST /api/HelpQuestion/SetHelpQuestionStatus */
export async function setHelpQuestionStatus(
  body: API.OrderStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/HelpQuestion/SetHelpQuestionStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/IncentivePayments.ts

New file
@@ -0,0 +1,36 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增奖励金发放 POST /api/IncentivePayments/AddIncentivePayments */
export async function addIncentivePayments(
  body: API.AddIncentivePaymentsInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IncentivePayments/AddIncentivePayments', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取奖励金发放管理分页列表 POST /api/IncentivePayments/GetIncentivePaymentsManagePage */
export async function getIncentivePaymentsManagePage(
  body: API.QueryIncentivePaymentsManageListInput,
  options?: API.RequestConfig
) {
  return request<API.IncentivePaymentsManageListOutputPageOutput>(
    '/api/IncentivePayments/GetIncentivePaymentsManagePage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/IndustrialPark.ts

New file
@@ -0,0 +1,92 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增产业园区 POST /api/IndustrialPark/AddIndustrialPark */
export async function addIndustrialPark(
  body: API.AddIndustrialParkInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustrialPark/AddIndustrialPark', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取产业园区信息详情 POST /api/IndustrialPark/GetIndustrialParkDetail */
export async function getIndustrialParkDetail(
  body: API.QueryIndustrialParkDetailInput,
  options?: API.RequestConfig
) {
  return request<API.IndustrialParkDetailOutput>('/api/IndustrialPark/GetIndustrialParkDetail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取产业园区下拉列表数据 GET /api/IndustrialPark/GetIndustrialParkDropDownList */
export async function getIndustrialParkDropDownList(options?: API.RequestConfig) {
  return request<API.IndustrialParkDropDownOutput[]>(
    '/api/IndustrialPark/GetIndustrialParkDropDownList',
    {
      method: 'GET',
      ...(options || {}),
    }
  );
}

/** 获取产业园区分页列表 POST /api/IndustrialPark/GetIndustrialParkPage */
export async function getIndustrialParkPage(
  body: API.QueryIndustrialParkListInput,
  options?: API.RequestConfig
) {
  return request<API.IndustrialParkListOutputPageOutput>(
    '/api/IndustrialPark/GetIndustrialParkPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 设置产业园区状态 POST /api/IndustrialPark/SetIndustrialParkStatus */
export async function setIndustrialParkStatus(
  body: API.SetIndustrialParkStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustrialPark/SetIndustrialParkStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新产业园区 POST /api/IndustrialPark/UpdateIndustrialPark */
export async function updateIndustrialPark(
  body: API.UpdateIndustrialParkInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustrialPark/UpdateIndustrialPark', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/IndustryBody.ts

New file
@@ -0,0 +1,157 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增行业机构企业信息 POST /api/IndustryBody/AddIndustryBody */
export async function addIndustryBody(body: API.AddIndustryBodyInput, options?: API.RequestConfig) {
  return request<number>('/api/IndustryBody/AddIndustryBody', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增行业机构审核信息 POST /api/IndustryBody/AddIndustryBodyAudit */
export async function addIndustryBodyAudit(
  body: API.AddIndustryBodyAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryBody/AddIndustryBodyAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取行业机构审核详情 GET /api/IndustryBody/GetIndustryBodyAuditDatilById */
export async function getIndustryBodyAuditDatilById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetIndustryBodyAuditDatilByIdParams,
  options?: API.RequestConfig
) {
  return request<API.IndustryBodyAuditDatilOutput>(
    '/api/IndustryBody/GetIndustryBodyAuditDatilById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取行业机构审核分页列表 POST /api/IndustryBody/GetIndustryBodyAuditPage */
export async function getIndustryBodyAuditPage(
  body: API.QueryIndustryBodyAuditListInput,
  options?: API.RequestConfig
) {
  return request<API.IndustryBodyAuditListOutputPageOutput>(
    '/api/IndustryBody/GetIndustryBodyAuditPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取行业机构企业信息详情 GET /api/IndustryBody/GetIndustryBodyDetail */
export async function getIndustryBodyDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetIndustryBodyDetailParams,
  options?: API.RequestConfig
) {
  return request<API.IndustryBodyDto>('/api/IndustryBody/GetIndustryBodyDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取行业机构分页列表 POST /api/IndustryBody/GetIndustryBodyPage */
export async function getIndustryBodyPage(
  body: API.QueryIndustryBodyListInput,
  options?: API.RequestConfig
) {
  return request<API.IndustryBodyListOutputPageOutput>('/api/IndustryBody/GetIndustryBodyPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取行业机构简单列表 GET /api/IndustryBody/GetIndustryBodySimpleList */
export async function getIndustryBodySimpleList(options?: API.RequestConfig) {
  return request<API.EnterpriseSimpleOutput[]>('/api/IndustryBody/GetIndustryBodySimpleList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取我的行业机构企业信息 POST /api/IndustryBody/GetMyIndustryBodyInfo */
export async function getMyIndustryBodyInfo(options?: API.RequestConfig) {
  return request<API.MyIndustryBodyDto>('/api/IndustryBody/GetMyIndustryBodyInfo', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 设置行业机构审核状态 POST /api/IndustryBody/SetIndustryBodyAuditStatus */
export async function setIndustryBodyAuditStatus(
  body: API.SetIndustryBodyAuditStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryBody/SetIndustryBodyAuditStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新行业机构企业信息 POST /api/IndustryBody/UpdateIndustryBody */
export async function updateIndustryBody(
  body: API.UpdateIndustryBodyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryBody/UpdateIndustryBody', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新行业机构审核信息 POST /api/IndustryBody/UpdateIndustryBodyAudit */
export async function updateIndustryBodyAudit(
  body: API.UpdateIndustryBodyAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryBody/UpdateIndustryBodyAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/IndustryMating.ts

New file
@@ -0,0 +1,163 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增行业配套企业信息 POST /api/IndustryMating/AddIndustryMating */
export async function addIndustryMating(
  body: API.AddIndustryMatingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryMating/AddIndustryMating', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增行业配套审核信息 POST /api/IndustryMating/AddIndustryMatingAudit */
export async function addIndustryMatingAudit(
  body: API.AddIndustryMatingAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryMating/AddIndustryMatingAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取行业配套审核详情 GET /api/IndustryMating/GetIndustryMatingAuditDatilById */
export async function getIndustryMatingAuditDatilById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetIndustryMatingAuditDatilByIdParams,
  options?: API.RequestConfig
) {
  return request<API.IndustryMatingAuditDatilOutput>(
    '/api/IndustryMating/GetIndustryMatingAuditDatilById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取行业配套审核分页列表 POST /api/IndustryMating/GetIndustryMatingAuditPage */
export async function getIndustryMatingAuditPage(
  body: API.QueryIndustryMatingAuditListInput,
  options?: API.RequestConfig
) {
  return request<API.IndustryMatingAuditListOutputPageOutput>(
    '/api/IndustryMating/GetIndustryMatingAuditPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取行业配套企业信息详情 GET /api/IndustryMating/GetIndustryMatingDetail */
export async function getIndustryMatingDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetIndustryMatingDetailParams,
  options?: API.RequestConfig
) {
  return request<API.IndustryMatingDto>('/api/IndustryMating/GetIndustryMatingDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取行业配套分页列表 POST /api/IndustryMating/GetIndustryMatingPage */
export async function getIndustryMatingPage(
  body: API.QueryIndustryMatingListInput,
  options?: API.RequestConfig
) {
  return request<API.IndustryMatingListOutputPageOutput>(
    '/api/IndustryMating/GetIndustryMatingPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取行业配套简单列表 GET /api/IndustryMating/GetIndustryMatingSimpleList */
export async function getIndustryMatingSimpleList(options?: API.RequestConfig) {
  return request<API.EnterpriseSimpleOutput[]>('/api/IndustryMating/GetIndustryMatingSimpleList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取我的行业配套企业信息 POST /api/IndustryMating/GetMyIndustryMatingInfo */
export async function getMyIndustryMatingInfo(options?: API.RequestConfig) {
  return request<API.MyIndustryMatingDto>('/api/IndustryMating/GetMyIndustryMatingInfo', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 设置行业配套审核状态 POST /api/IndustryMating/SetIndustryMatingAuditStatus */
export async function setIndustryMatingAuditStatus(
  body: API.SetIndustryMatingAuditStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryMating/SetIndustryMatingAuditStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新行业配套企业信息 POST /api/IndustryMating/UpdateIndustryMating */
export async function updateIndustryMating(
  body: API.UpdateIndustryMatingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryMating/UpdateIndustryMating', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新行业配套审核信息 POST /api/IndustryMating/UpdateIndustryMatingAudit */
export async function updateIndustryMatingAudit(
  body: API.UpdateIndustryMatingAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/IndustryMating/UpdateIndustryMatingAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Information.ts

New file
@@ -0,0 +1,673 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 采集删除资讯 POST /api/Information/AcquisitionDeleteInformation */
export async function acquisitionDeleteInformation(
  body: API.BaseIdInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/AcquisitionDeleteInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 采用资讯 POST /api/Information/AdoptInformation */
export async function adoptInformation(body: API.BaseIdInput, options?: API.RequestConfig) {
  return request<number>('/api/Information/AdoptInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯广告下架 GET /api/Information/AdvertiseOffShelf */
export async function advertiseOffShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertiseOffShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/AdvertiseOffShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 资讯广告上架 GET /api/Information/AdvertiseOnShelf */
export async function advertiseOnShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertiseOnShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/AdvertiseOnShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 资讯关注/取消关注 GET /api/Information/AttentOrNot */
export async function attentOrNot(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIattentOrNotParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/AttentOrNot', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 保存/发布资讯 POST /api/Information/CreateInformation */
export async function createInformation(
  body: API.CreateInformationInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Information/CreateInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯广告新增上架 POST /api/Information/CreateInformationAdvertise */
export async function createInformationAdvertise(
  body: API.CreateInformationAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Information/CreateInformationAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户发布资讯 POST /api/Information/CustomCreateInformation */
export async function customCreateInformation(
  body: API.CreateInformationInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/CustomCreateInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除资讯 GET /api/Information/DeleteInformation */
export async function deleteInformation(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInformationParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/DeleteInformation', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取采集资讯分页列表 POST /api/Information/GetAcquisitionInformationPage */
export async function getAcquisitionInformationPage(
  body: API.QueryAcquisitionInformationInput,
  options?: API.RequestConfig
) {
  return request<API.AcquisitionInformationListOutputPageOutput>(
    '/api/Information/GetAcquisitionInformationPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 用户资讯管理分页列表 POST /api/Information/GetCustomInformationForManage */
export async function getCustomInformationForManage(
  body: API.GetInformationForManageInput,
  options?: API.RequestConfig
) {
  return request<API.InformationForManagePageOutput>(
    '/api/Information/GetCustomInformationForManage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 资讯头条 POST /api/Information/GetHeadlineInformation */
export async function getHeadlineInformation(
  body: API.GetHeadlineInformationInput,
  options?: API.RequestConfig
) {
  return request<API.HeadlineInformation[]>('/api/Information/GetHeadlineInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 首页--热门资讯榜 GET /api/Information/GetHotInformationAdvertise */
export async function getHotInformationAdvertise(options?: API.RequestConfig) {
  return request<API.HotInformationAdvertiseInfo[]>('/api/Information/GetHotInformationAdvertise', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 行业资讯--热门资讯 POST /api/Information/GetHotInformationAdvertiseByCategory */
export async function getHotInformationAdvertiseByCategory(
  body: API.GetInformationAdvertiseByCategoryInput,
  options?: API.RequestConfig
) {
  return request<API.HotInformationAdvertiseInfoPageOutput>(
    '/api/Information/GetHotInformationAdvertiseByCategory',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取资讯详情 GET /api/Information/GetInformation */
export async function getInformation(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInformationParams,
  options?: API.RequestConfig
) {
  return request<API.InformationDetail>('/api/Information/GetInformation', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 资讯广告详情 GET /api/Information/GetInformationAdvertise */
export async function getInformationAdvertise(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInformationAdvertiseParams,
  options?: API.RequestConfig
) {
  return request<API.InformationAdvertiseDetail>('/api/Information/GetInformationAdvertise', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 资讯广告列表 POST /api/Information/GetInformationAdvertisesForManage */
export async function getInformationAdvertisesForManage(
  body: API.GetInformationAdvertisesForManageInput,
  options?: API.RequestConfig
) {
  return request<API.InformationAdvertiseForManagePageOutput>(
    '/api/Information/GetInformationAdvertisesForManage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 行业资讯---资讯 POST /api/Information/GetInformationByCategory */
export async function getInformationByCategory(
  body: API.GetInformationAdvertiseByCategoryInput,
  options?: API.RequestConfig
) {
  return request<API.InformationInfoPageOutput>('/api/Information/GetInformationByCategory', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 小程序--获取他的资讯 POST /api/Information/GetInformationByUserId */
export async function getInformationByUserId(
  body: API.GeInformationByUserIdInput,
  options?: API.RequestConfig
) {
  return request<API.InformationForManagePageOutput>('/api/Information/GetInformationByUserId', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 行业资讯--详情 GET /api/Information/GetInformationForDetail */
export async function getInformationForDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInformationForDetailParams,
  options?: API.RequestConfig
) {
  return request<API.InformationDetailInfo>('/api/Information/GetInformationForDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 首页--行业资讯 GET /api/Information/GetInformationForHomePage */
export async function getInformationForHomePage(options?: API.RequestConfig) {
  return request<API.InformationForHomePageDto[]>('/api/Information/GetInformationForHomePage', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 资讯管理列表 POST /api/Information/GetInformationForManage */
export async function getInformationForManage(
  body: API.GetInformationForManageInput,
  options?: API.RequestConfig
) {
  return request<API.InformationForManagePageOutput>('/api/Information/GetInformationForManage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 行业资讯--相关推荐 POST /api/Information/GetInformationForRecommend */
export async function getInformationForRecommend(
  body: API.GetInformationAdvertiseByCategoryInput,
  options?: API.RequestConfig
) {
  return request<API.InformationInfo[]>('/api/Information/GetInformationForRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取资讯展示详情 POST /api/Information/GetInformationShowDetail */
export async function getInformationShowDetail(body: API.BaseIdInput, options?: API.RequestConfig) {
  return request<API.InformationShowDetailDto>('/api/Information/GetInformationShowDetail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取热门资讯展示列表 POST /api/Information/GetInformationShowHotPage */
export async function getInformationShowHotPage(
  body: API.QueryInformationShowPageInput,
  options?: API.RequestConfig
) {
  return request<API.InformationShowListDtoPageOutput>(
    '/api/Information/GetInformationShowHotPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取资讯展示列表 POST /api/Information/GetInformationShowPage */
export async function getInformationShowPage(
  body: API.QueryInformationShowPageInput,
  options?: API.RequestConfig
) {
  return request<API.InformationShowListDtoPageOutput>('/api/Information/GetInformationShowPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取资讯相关推荐展示列表 POST /api/Information/GetInformationShowRecommendList */
export async function getInformationShowRecommendList(
  body: API.QueryInformationShowRecommendListInput,
  options?: API.RequestConfig
) {
  return request<API.InformationShowListDtoPageOutput>(
    '/api/Information/GetInformationShowRecommendList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 资讯审核列表 POST /api/Information/GetInformationWaitForCheck */
export async function getInformationWaitForCheck(
  body: API.GetInformationWaitForCheckInput,
  options?: API.RequestConfig
) {
  return request<API.InformationWaitForCheckPageOutput>(
    '/api/Information/GetInformationWaitForCheck',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取资讯广告位最后排序 GET /api/Information/GetMaxAdvertiseSequence */
export async function getMaxAdvertiseSequence(options?: API.RequestConfig) {
  return request<number>('/api/Information/GetMaxAdvertiseSequence', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 我的关注（资讯） POST /api/Information/GetMyAttentions */
export async function getMyAttentions(
  body: API.GetMyInformationAttentionsInput,
  options?: API.RequestConfig
) {
  return request<API.MyInformationAttentionInfoPageOutput>('/api/Information/GetMyAttentions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 我的资讯 POST /api/Information/GetMyInformation */
export async function getMyInformation(
  body: API.GetMyInformationInput,
  options?: API.RequestConfig
) {
  return request<API.InformationForManagePageOutput>('/api/Information/GetMyInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 最近发布资讯 GET /api/Information/GetMyRecentInformation */
export async function getMyRecentInformation(options?: API.RequestConfig) {
  return request<API.MyRecentInformationDto[]>('/api/Information/GetMyRecentInformation', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 卓玥学社公众号获取文章脚本--测试使用 POST /api/Information/GetWxPublishWritingWorker */
export async function getWxPublishWritingWorker(options?: API.RequestConfig) {
  return request<number>('/api/Information/GetWxPublishWritingWorker', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 资讯--浏览 POST /api/Information/InformationBrowse */
export async function informationBrowse(
  body: API.InformationViewInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/InformationBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯审核 POST /api/Information/InformationCheck */
export async function informationCheck(
  body: API.InformationCheckInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/InformationCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 行业资讯--打赏 POST /api/Information/InformationReward */
export async function informationReward(
  body: API.InformationRewardInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Information/InformationReward', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯--点赞 POST /api/Information/InformationThumbsUp */
export async function informationThumbsUp(
  body: API.InformationThumbsUpInputV2,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/InformationThumbsUp', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯置顶 GET /api/Information/MyInformationPlaceTop */
export async function myInformationPlaceTop(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APImyInformationPlaceTopParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/MyInformationPlaceTop', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 资讯下架 GET /api/Information/OffShelf */
export async function offShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIoffShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/OffShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 资讯上架 GET /api/Information/OnShelf */
export async function onShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIonShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/OnShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 设置资讯推荐状态 POST /api/Information/SetInformationRecommendStatus */
export async function setInformationRecommendStatus(
  body: API.SetInformationRecommendStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/SetInformationRecommendStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 分享资讯 POST /api/Information/ShareInformation */
export async function shareInformation(
  body: API.ShareInformationInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/ShareInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯编辑 POST /api/Information/UpdateInformation */
export async function updateInformation(
  body: API.UpdateInformationInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/UpdateInformation', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯广告编辑上架 POST /api/Information/UpdateInformationAdvertise */
export async function updateInformationAdvertise(
  body: API.UpdateInformationAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/UpdateInformationAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资讯编辑且直接审核通过 POST /api/Information/UpdateInformationWithAuditPass */
export async function updateInformationWithAuditPass(
  body: API.UpdateInformationInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Information/UpdateInformationWithAuditPass', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户资讯广告投放 POST /api/Information/UserCreateInformationAdvertise */
export async function userCreateInformationAdvertise(
  body: API.UserCreateInformationAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Information/UserCreateInformationAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Insurance.ts

New file
@@ -0,0 +1,1415 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 上传保单信息 POST /api/Insurance/AddAttachmentForBill */
export async function addAttachmentForBill(
  body: API.UploadAttachmentInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/AddAttachmentForBill', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增投保计划 POST /api/Insurance/AddInsurePlan */
export async function addInsurePlan(body: API.AddInsurePlanInput, options?: API.RequestConfig) {
  return request<number>('/api/Insurance/AddInsurePlan', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新建  保险方案 POST /api/Insurance/AddInsureProject */
export async function addInsureProject(
  body: API.AddInsureProjectInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Insurance/AddInsureProject', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 保存更新常用信息 POST /api/Insurance/AddUpdateInsureCommonInfo */
export async function addUpdateInsureCommonInfo(
  body: API.AddUpdateInsureCommonInfoInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Insurance/AddUpdateInsureCommonInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 保单批单管理 POST /api/Insurance/AddUpdateOfflineInsureBatchBill */
export async function addUpdateOfflineInsureBatchBill(
  body: API.InsureBatchBillInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/AddUpdateOfflineInsureBatchBill', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 批量更新产品状态 POST /api/Insurance/BatchUpdateInsureProductStatus */
export async function batchUpdateInsureProductStatus(
  body: API.UpdateInsureProductStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/BatchUpdateInsureProductStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取批单的保险费用 POST /api/Insurance/CalCulateBatchInsureMoney */
export async function calCulateBatchInsureMoney(
  body: API.InsureBatchBillInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/CalCulateBatchInsureMoney', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取过期批单的保险费用 POST /api/Insurance/CalCulateBatchInsureMoneyForExpire */
export async function calCulateBatchInsureMoneyForExpire(
  body: API.InsureBatchBillInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/CalCulateBatchInsureMoneyForExpire', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取投保的费用 POST /api/Insurance/CalCulateInsureMoney */
export async function calCulateInsureMoney(
  body: API.GetInsureMoneyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/CalCulateInsureMoney', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 执行投保临近到期通知(自行调试) POST /api/Insurance/ChangeInsurancePolicyCloseEndDateStatus */
export async function changeInsurancePolicyCloseEndDateStatus(options?: API.RequestConfig) {
  return request<number>('/api/Insurance/ChangeInsurancePolicyCloseEndDateStatus', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 检测常用信息是否已经存在 POST /api/Insurance/CheckIsExsitInsureCommonInfo */
export async function checkIsExsitInsureCommonInfo(
  body: API.AddUpdateInsureCommonInfoInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/CheckIsExsitInsureCommonInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 检测职业类别是否符合产品方案投保要求 POST /api/Insurance/CheckJobTypeIsAllowInsure */
export async function checkJobTypeIsAllowInsure(
  body: API.CheckJobTypeIsAllowInsureInput,
  options?: API.RequestConfig
) {
  return request<boolean>('/api/Insurance/CheckJobTypeIsAllowInsure', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 线下批单审核 POST /api/Insurance/CheckOfflineBatchInsureBill */
export async function checkOfflineBatchInsureBill(
  body: API.CheckOfflineInsureBatchBillInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/CheckOfflineBatchInsureBill', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 线下投保审核 POST /api/Insurance/CheckOfflineInsureBill */
export async function checkOfflineInsureBill(
  body: API.CheckOfflineInsureBillInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/CheckOfflineInsureBill', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取客户钱包信息 GET /api/Insurance/CheckUserWalletBalanceInfoForTransfer */
export async function checkUserWalletBalanceInfoForTransfer(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIcheckUserWalletBalanceInfoForTransferParams,
  options?: API.RequestConfig
) {
  return request<API.CheckUserWalletBalanceInfoOutput>(
    '/api/Insurance/CheckUserWalletBalanceInfoForTransfer',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 线下批单到账审核 POST /api/Insurance/ConfirmToAccountForBatchInsure */
export async function confirmToAccountForBatchInsure(
  body: API.ConfirmToAccountBatchInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/ConfirmToAccountForBatchInsure', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 线下到账确认 POST /api/Insurance/ConfirmToAccountForInsure */
export async function confirmToAccountForInsure(
  body: API.ConfirmToAccountInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/ConfirmToAccountForInsure', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取客户关联协议模板文件 POST /api/Insurance/ContractTemplateFileDown */
export async function contractTemplateFileDown(
  body: API.ContractTemplateDownInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Insurance/ContractTemplateFileDown', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除常用信息 DELETE /api/Insurance/DeleteCommonInfo */
export async function deleteCommonInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteCommonInfoParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/DeleteCommonInfo', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除投保计划单个明细 GET /api/Insurance/DeletedInsurePlanDetail */
export async function deletedInsurePlanDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeletedInsurePlanDetailParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/DeletedInsurePlanDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除保险 GET /api/Insurance/DeleteInsurancePolicy */
export async function deleteInsurancePolicy(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsurancePolicyParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/DeleteInsurancePolicy', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除批单 POST /api/Insurance/DeleteInsureBatchBill */
export async function deleteInsureBatchBill(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsureBatchBillParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/DeleteInsureBatchBill', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除保险方案 GET /api/Insurance/DeleteInsureProject */
export async function deleteInsureProject(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsureProjectParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/DeleteInsureProject', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 意外险批量退保(仅支持意外险) POST /api/Insurance/EnterpriseBatchAccidentRefund */
export async function enterpriseBatchAccidentRefund(
  body: API.EnterpriseBatchRefundInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsureRefundSendResponse>('/api/Insurance/EnterpriseBatchAccidentRefund', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 雇主险批量退保(仅支持雇主险) POST /api/Insurance/EnterpriseBatchRefund */
export async function enterpriseBatchRefund(
  body: API.EnterpriseBatchRefundInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsureRefundSendResponse>('/api/Insurance/EnterpriseBatchRefund', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 执行投保计划(自行调试) POST /api/Insurance/ExecInsuracePlanToInsure */
export async function execInsuracePlanToInsure(options?: API.RequestConfig) {
  return request<number>('/api/Insurance/ExecInsuracePlanToInsure', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 批单管理--导出名单 GET /api/Insurance/ExportInsureBatchStaff */
export async function exportInsureBatchStaff(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIexportInsureBatchStaffParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/ExportInsureBatchStaff', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出人员名单 GET /api/Insurance/ExportInsureStaff */
export async function exportInsureStaff(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIexportInsureStaffParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/ExportInsureStaff', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取批单下参保人员列表 POST /api/Insurance/GetBatchBillDetailPagedList */
export async function getBatchBillDetailPagedList(
  body: API.GetBatchBillDetailInput,
  options?: API.RequestConfig
) {
  return request<API.InsurancePolicyDetailInfoPageOutput>(
    '/api/Insurance/GetBatchBillDetailPagedList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取保单或批单下 增加 删除 更改人员列表 GET /api/Insurance/GetBatchBillStaffList */
export async function getBatchBillStaffList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetBatchBillStaffListParams,
  options?: API.RequestConfig
) {
  return request<API.GetBatchBillStaffListOutput>('/api/Insurance/GetBatchBillStaffList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取企业投保地址 GET /api/Insurance/GetCompanyInsureAddressList */
export async function getCompanyInsureAddressList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCompanyInsureAddressListParams,
  options?: API.RequestConfig
) {
  return request<API.GetCompanyInsureAddressList[]>('/api/Insurance/GetCompanyInsureAddressList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 投保详情导出 POST /api/Insurance/GetInsurancePolicyDetailExport */
export async function getInsurancePolicyDetailExport(
  body: API.GetInsurancePolicyDetailInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/GetInsurancePolicyDetailExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 投保详情导出（江西模式） POST /api/Insurance/GetInsurancePolicyDetailExportJx */
export async function getInsurancePolicyDetailExportJx(
  body: API.GetInsurancePolicyDetailInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/GetInsurancePolicyDetailExportJx', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取保单人员列表无分页 POST /api/Insurance/GetInsurancePolicyDetailList */
export async function getInsurancePolicyDetailList(
  body: API.GetInsurancePolicyDetailInput,
  options?: API.RequestConfig
) {
  return request<API.InsurancePolicyDetailInfo[]>('/api/Insurance/GetInsurancePolicyDetailList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 投保详情列表 POST /api/Insurance/GetInsurancePolicyDetailPagedList */
export async function getInsurancePolicyDetailPagedList(
  body: API.GetInsurancePolicyDetailInput,
  options?: API.RequestConfig
) {
  return request<API.InsurancePolicyDetailInfoPageOutput>(
    '/api/Insurance/GetInsurancePolicyDetailPagedList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 投保详情列表头部 GET /api/Insurance/GetInsurancePolicyDetailPagedListHead */
export async function getInsurancePolicyDetailPagedListHead(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsurancePolicyDetailPagedListHeadParams,
  options?: API.RequestConfig
) {
  return request<API.InsurancePolicyInfo>('/api/Insurance/GetInsurancePolicyDetailPagedListHead', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 投标详情列表 (江西模式) POST /api/Insurance/GetInsurancePolicyDetailPagedListJx */
export async function getInsurancePolicyDetailPagedListJx(
  body: API.GetInsurancePolicyDetailInput,
  options?: API.RequestConfig
) {
  return request<API.InsurancePolicyDetailInfoJxPageOutput>(
    '/api/Insurance/GetInsurancePolicyDetailPagedListJx',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取保险管理列表 POST /api/Insurance/GetInsurancePolicyInfoPagedList */
export async function getInsurancePolicyInfoPagedList(
  body: API.GetInsurancePoliciesInput,
  options?: API.RequestConfig
) {
  return request<API.InsurancePolicyInfoPageOutput>(
    '/api/Insurance/GetInsurancePolicyInfoPagedList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 投保列表 POST /api/Insurance/GetInsurancePolicyList */
export async function getInsurancePolicyList(
  body: API.GetInsurancePolicyListInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsurancePolicyListPageOutput>('/api/Insurance/GetInsurancePolicyList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 投保列表导出 POST /api/Insurance/GetInsurancePolicyListExport */
export async function getInsurancePolicyListExport(
  body: API.GetInsurancePolicyListInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/GetInsurancePolicyListExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 人员投保记录/(新)投保人投保次数 POST /api/Insurance/GetInsurancePolicyRecords */
export async function getInsurancePolicyRecords(
  body: API.GetInsurancePolicyRecordsInput,
  options?: API.RequestConfig
) {
  return request<API.InsurancePolicyRecordPageOutput>('/api/Insurance/GetInsurancePolicyRecords', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 按客户进行统计 POST /api/Insurance/GetInsuranceStaticByCustomer */
export async function getInsuranceStaticByCustomer(
  body: API.GetInsurancePoliciesInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsuranceStaticByCustomerDtoPageOutput>(
    '/api/Insurance/GetInsuranceStaticByCustomer',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 按客户进行统计导出 POST /api/Insurance/GetInsuranceStaticByCustomerExport */
export async function getInsuranceStaticByCustomerExport(
  body: API.GetInsurancePoliciesInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/GetInsuranceStaticByCustomerExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取日志 POST /api/Insurance/GetInsureActionLogList */
export async function getInsureActionLogList(
  body: API.GetInsureActionLogInput,
  options?: API.RequestConfig
) {
  return request<API.InsureActionLogOutputPageOutput>('/api/Insurance/GetInsureActionLogList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取批单详情 GET /api/Insurance/GetInsureBatchBillDetail */
export async function getInsureBatchBillDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureBatchBillDetailParams,
  options?: API.RequestConfig
) {
  return request<API.InsureBatchBillDetailDto>('/api/Insurance/GetInsureBatchBillDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取常用信息详情 GET /api/Insurance/GetInsureCommonInfoDetail */
export async function getInsureCommonInfoDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureCommonInfoDetailParams,
  options?: API.RequestConfig
) {
  return request<API.InsureCommonInfoDto>('/api/Insurance/GetInsureCommonInfoDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取常用信息数据 POST /api/Insurance/GetInsureCommonInfoList */
export async function getInsureCommonInfoList(
  body: API.GetCommonInfoInput,
  options?: API.RequestConfig
) {
  return request<API.InsureCommonInfoDtoPageOutput>('/api/Insurance/GetInsureCommonInfoList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取不含分页常用信息列表 POST /api/Insurance/GetInsureCommonInfoNoPageList */
export async function getInsureCommonInfoNoPageList(
  body: API.GetCommonInfoInput,
  options?: API.RequestConfig
) {
  return request<API.InsureCommonInfoDto[]>('/api/Insurance/GetInsureCommonInfoNoPageList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取职位名称树 GET /api/Insurance/GetInsureCommonInfoTreeList */
export async function getInsureCommonInfoTreeList(options?: API.RequestConfig) {
  return request<API.InsurePersonSortBigTypeTree[]>('/api/Insurance/GetInsureCommonInfoTreeList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 投保详情 GET /api/Insurance/GetInsureInfo */
export async function getInsureInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureInfoParams,
  options?: API.RequestConfig
) {
  return request<API.GetInsureInfo>('/api/Insurance/GetInsureInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取保单需更新后的起止有效期 GET /api/Insurance/GetInsureNewEffectDateTime */
export async function getInsureNewEffectDateTime(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureNewEffectDateTimeParams,
  options?: API.RequestConfig
) {
  return request<API.GetInsureEffectDateTimeOutput>('/api/Insurance/GetInsureNewEffectDateTime', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 查看人员分类 POST /api/Insurance/GetInsurePersonSortList */
export async function getInsurePersonSortList(
  body: API.GetInsurePersonSortListInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsurePersonSortListPageOutput>('/api/Insurance/GetInsurePersonSortList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取职业类别列表 无分页 POST /api/Insurance/GetInsurePersonSortNoPageList */
export async function getInsurePersonSortNoPageList(
  body: API.GetInsurePersonSortListInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsurePersonSortList[]>('/api/Insurance/GetInsurePersonSortNoPageList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取计划详情投保批次 POST /api/Insurance/GetInsurePlanDetailList */
export async function getInsurePlanDetailList(
  body: API.GetInsurePlanDetailInput,
  options?: API.RequestConfig
) {
  return request<API.InsurePlanDetailDtoPageOutput>('/api/Insurance/GetInsurePlanDetailList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 导出计划详情投保批次 POST /api/Insurance/GetInsurePlanDetailListExport */
export async function getInsurePlanDetailListExport(
  body: API.GetInsurePlanDetailInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/GetInsurePlanDetailListExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取计划详细人员名单 POST /api/Insurance/GetInsurePlanDetailStaff */
export async function getInsurePlanDetailStaff(
  body: API.GetInsurePlanDetailInput,
  options?: API.RequestConfig
) {
  return request<API.InsurePlanStaffDtoPageOutput>('/api/Insurance/GetInsurePlanDetailStaff', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 导出计划详细人员名单 POST /api/Insurance/GetInsurePlanDetailStaffExport */
export async function getInsurePlanDetailStaffExport(
  body: API.GetInsurePlanDetailInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/GetInsurePlanDetailStaffExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取投保计划详情基本信息 POST /api/Insurance/GetInsurePlanHead */
export async function getInsurePlanHead(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsurePlanHeadParams,
  options?: API.RequestConfig
) {
  return request<API.InsurePlanDto>('/api/Insurance/GetInsurePlanHead', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 人员投保计划 POST /api/Insurance/GetInsurePlanList */
export async function getInsurePlanList(body: API.GetInsurePlanInput, options?: API.RequestConfig) {
  return request<API.InsurePlanDtoPageOutput>('/api/Insurance/GetInsurePlanList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 人员投保计划导出 POST /api/Insurance/GetInsurePlanListExport */
export async function getInsurePlanListExport(
  body: API.GetInsurePlanInfoExportInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/GetInsurePlanListExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取产品列表 POST /api/Insurance/GetInsureProductList */
export async function getInsureProductList(
  body: API.GetInsureProductInput,
  options?: API.RequestConfig
) {
  return request<API.InsureProductDtoPageOutput>('/api/Insurance/GetInsureProductList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取保险方案 GET /api/Insurance/GetInsureProjectByShortId */
export async function getInsureProjectByShortId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureProjectByShortIdParams,
  options?: API.RequestConfig
) {
  return request<API.GetInsureProjectByShortId>('/api/Insurance/GetInsureProjectByShortId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取保险方案列表 POST /api/Insurance/GetInsureProjectList */
export async function getInsureProjectList(
  body: API.GetInsureProjectListInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsureProjectListPageOutput>('/api/Insurance/GetInsureProjectList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取批单列表 POST /api/Insurance/GetOfflineInsureBatchBillList */
export async function getOfflineInsureBatchBillList(
  body: API.GetInsuranceBatchBillInput,
  options?: API.RequestConfig
) {
  return request<API.InsureBatchBillDtoPageOutput>('/api/Insurance/GetOfflineInsureBatchBillList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取保单下修改记录 GET /api/Insurance/GetOfflineInsureBatchBillNoPageList */
export async function getOfflineInsureBatchBillNoPageList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOfflineInsureBatchBillNoPageListParams,
  options?: API.RequestConfig
) {
  return request<API.InsureBatchBillDto[]>('/api/Insurance/GetOfflineInsureBatchBillNoPageList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 小程序获取手机号 GET /api/Insurance/GetPhoneNumber */
export async function getPhoneNumber(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPhoneNumberParams,
  options?: API.RequestConfig
) {
  return request<API.GetPhoneNumberInfo>('/api/Insurance/GetPhoneNumber', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 使用手机号获取职员信息 GET /api/Insurance/GetStaffByIdNum */
export async function getStaffByIdNum(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetStaffByIdNumParams,
  options?: API.RequestConfig
) {
  return request<API.GetPhoneNumberInfo>('/api/Insurance/GetStaffByIdNum', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取不限制的小程序码 POST /api/Insurance/GetUnlimitedQRCode */
export async function getUnlimitedQRCode(
  body: API.UnlimitedQRCodeInput,
  options?: API.RequestConfig
) {
  return request<API.UnlimitedQRCodeDto>('/api/Insurance/GetUnlimitedQRCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取用户钱包开通列表 GET /api/Insurance/GetUserOpenWalletList */
export async function getUserOpenWalletList(options?: API.RequestConfig) {
  return request<API.WalletAccountTypeMainStatusInfo[]>('/api/Insurance/GetUserOpenWalletList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取保险工作台的数据明细 GET /api/Insurance/GetWorkPlatSumInfo */
export async function getWorkPlatSumInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWorkPlatSumInfoParams,
  options?: API.RequestConfig
) {
  return request<API.GetWorkPlatSumInfoOutput>('/api/Insurance/GetWorkPlatSumInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 身份证导入职员解析 POST /api/Insurance/ImportIdentityCards */
export async function importIdentityCards(
  body: API.ImportIdentityCardInput,
  options?: API.RequestConfig
) {
  return request<API.ImportIdentityCardResult[]>('/api/Insurance/ImportIdentityCards', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 导入职员解析 POST /api/Insurance/ImportInsStaffToList */
export async function importInsStaffToList(
  body: API.ExportInsStaffInput,
  options?: API.RequestConfig
) {
  return request<API.ImportInsStaffAnalysisList[]>('/api/Insurance/ImportInsStaffToList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上传人员名单解析 POST /api/Insurance/ImportInsStaffToListNew */
export async function importInsStaffToListNew(
  body: API.ExportInsStaffInput,
  options?: API.RequestConfig
) {
  return request<API.ImportInsStaffAnalysisListOutput>('/api/Insurance/ImportInsStaffToListNew', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 保险管理列表导出 POST /api/Insurance/InsurancePoliciesExport */
export async function insurancePoliciesExport(
  body: API.GetInsurancePoliciesInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/InsurancePoliciesExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 保险管理列表导出 POST /api/Insurance/InsurancePoliciesExportJx */
export async function insurancePoliciesExportJx(
  body: API.GetInsurancePoliciesInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/InsurancePoliciesExportJx', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 投保详情列表导出 POST /api/Insurance/InsurancePolicyDetailExport */
export async function insurancePolicyDetailExport(
  body: API.GetInsurancePolicyDetailInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/InsurancePolicyDetailExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 人员投保记录/(新)投保人投保次数导出 POST /api/Insurance/InsurancePolicyRecordsExport */
export async function insurancePolicyRecordsExport(
  body: API.GetInsurancePolicyRecordsExportInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/InsurancePolicyRecordsExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 投保 POST /api/Insurance/Insure */
export async function insure(body: API.InsureInput, options?: API.RequestConfig) {
  return request<API.InsureDto>('/api/Insurance/Insure', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 人员批增投保 POST /api/Insurance/InsureBatchAdd */
export async function insureBatchAdd(body: API.InsureBatchAddInput, options?: API.RequestConfig) {
  return request<API.InsureDto>('/api/Insurance/InsureBatchAdd', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 退保 GET /api/Insurance/InsureRefund */
export async function insureRefund(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIinsureRefundParams,
  options?: API.RequestConfig
) {
  return request<API.GetInsureRefundSendResponse>('/api/Insurance/InsureRefund', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 线下产品投保 POST /api/Insurance/OfflineInsure */
export async function offlineInsure(body: API.InsureInput, options?: API.RequestConfig) {
  return request<API.InsureDto>('/api/Insurance/OfflineInsure', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 批单管理数据导出 POST /api/Insurance/OfflineInsureBatchBillListExport */
export async function offlineInsureBatchBillListExport(
  body: API.GetInsuranceBatchBillInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Insurance/OfflineInsureBatchBillListExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 保单审核通过 POST /api/Insurance/OfflineInsureBillPass */
export async function offlineInsureBillPass(
  body: API.OfflineInsureBillPassInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/OfflineInsureBillPass', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 线下产品投保江西模式 POST /api/Insurance/OfflineInsureJx */
export async function offlineInsureJx(body: API.InsureInput, options?: API.RequestConfig) {
  return request<API.InsureDto>('/api/Insurance/OfflineInsureJx', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 批单余额支付 POST /api/Insurance/PayOfflineBatchInsureBill */
export async function payOfflineBatchInsureBill(
  body: API.PayOfflineInsureBillInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/PayOfflineBatchInsureBill', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 余额支付 POST /api/Insurance/PayOfflineInsureBill */
export async function payOfflineInsureBill(
  body: API.PayOfflineInsureBillInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/PayOfflineInsureBill', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置投保驳回 POST /api/Insurance/UpdateInsureBillSetFailture */
export async function updateInsureBillSetFailture(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIupdateInsureBillSetFailtureParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UpdateInsureBillSetFailture', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 更新保单生效起始截止日期 GET /api/Insurance/UpdateInsureEffectDateTime */
export async function updateInsureEffectDateTime(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIupdateInsureEffectDateTimeParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UpdateInsureEffectDateTime', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 更新产品状态 GET /api/Insurance/UpdateInsureProductStatus */
export async function updateInsureProductStatus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIupdateInsureProductStatusParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UpdateInsureProductStatus', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 更新场地码状态 GET /api/Insurance/UpdateInsureProjectStatus */
export async function updateInsureProjectStatus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIupdateInsureProjectStatusParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UpdateInsureProjectStatus', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 批单上传附件 POST /api/Insurance/UploadBatchAttachmentUrl */
export async function uploadBatchAttachmentUrl(
  body: API.UploadBatchAttachmentUrlInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UploadBatchAttachmentUrl', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 批单 转账汇款 上传转账凭证 POST /api/Insurance/UploadBatchInsureBillUrl */
export async function uploadBatchInsureBillUrl(
  body: API.UploadBatchPayVoucherUrlInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UploadBatchInsureBillUrl', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置批单状态为失败 GET /api/Insurance/UploadBatchInsureFailure */
export async function uploadBatchInsureFailure(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIuploadBatchInsureFailureParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UploadBatchInsureFailure', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 保存企业关联协议文件 POST /api/Insurance/UploadCustomerContract */
export async function uploadCustomerContract(
  body: API.ContractUploadInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UploadCustomerContract', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上传投保单 POST /api/Insurance/UploadInsureBillFile */
export async function uploadInsureBillFile(
  body: API.UploadInsureBillFileInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UploadInsureBillFile', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 转账汇款 上传转账凭证 POST /api/Insurance/UploadInsureBillUrl */
export async function uploadInsureBillUrl(
  body: API.UploadVoucherUrlInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Insurance/UploadInsureBillUrl', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/InsuranceClaim.ts

File was deleted

 src/services/api/InsuranceOrder.ts

File was deleted

 src/services/api/InsureConsult.ts

New file
@@ -0,0 +1,141 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增咨询跟进 POST /api/InsureConsult/AddInsureConsultFollow */
export async function addInsureConsultFollow(
  body: API.CreateInsureConsultFollowInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureConsult/AddInsureConsultFollow', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增保险咨询 POST /api/InsureConsult/CreateOrEditInsureConsult */
export async function createOrEditInsureConsult(
  body: API.CreateOrEditInsureConsultInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/InsureConsult/CreateOrEditInsureConsult', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除咨询 DELETE /api/InsureConsult/DeleteInsureConsult */
export async function deleteInsureConsult(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsureConsultParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureConsult/DeleteInsureConsult', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 咨询列表导出 POST /api/InsureConsult/GetInsureConsultExportList */
export async function getInsureConsultExportList(
  body: API.GetInsureConsultExportInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/InsureConsult/GetInsureConsultExportList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取咨询跟进列表 POST /api/InsureConsult/GetInsureConsultFollowList */
export async function getInsureConsultFollowList(
  body: API.GetInsureConsultFollowInput,
  options?: API.RequestConfig
) {
  return request<API.InsureConsultFollowDtoPageOutput>(
    '/api/InsureConsult/GetInsureConsultFollowList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 根据ID获取咨询详情 GET /api/InsureConsult/GetInsureConsultInfoById */
export async function getInsureConsultInfoById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureConsultInfoByIdParams,
  options?: API.RequestConfig
) {
  return request<API.InsureConsultInfoDto>('/api/InsureConsult/GetInsureConsultInfoById', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取咨询列表 POST /api/InsureConsult/GetInsureConsultList */
export async function getInsureConsultList(
  body: API.GetInsureConsultInput,
  options?: API.RequestConfig
) {
  return request<API.InsureConsultDtoPageOutput>('/api/InsureConsult/GetInsureConsultList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 根据咨询ID获取最新跟进详情 GET /api/InsureConsult/GetNewestInsureConsultInfo */
export async function getNewestInsureConsultInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetNewestInsureConsultInfoParams,
  options?: API.RequestConfig
) {
  return request<API.InsureConsultFollowDto>('/api/InsureConsult/GetNewestInsureConsultInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 设置咨询状态 POST /api/InsureConsult/SetInsureConsultStatus */
export async function setInsureConsultStatus(
  body: API.SetNormalStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureConsult/SetInsureConsultStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/InsureMarketProduct.ts

New file
@@ -0,0 +1,231 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 判断投保城市是否允许投保 POST /api/InsureMarketProduct/CheckInsureCityIsAllow */
export async function checkInsureCityIsAllow(
  body: API.CheckInsureCityIsAllowInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureMarketProduct/CheckInsureCityIsAllow', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增删除保险 POST /api/InsureMarketProduct/CreateOrEditInsureProduct */
export async function createOrEditInsureProduct(
  body: API.CreateOrEditMarketProductInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/InsureMarketProduct/CreateOrEditInsureProduct', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除保险 DELETE /api/InsureMarketProduct/DeleteInsureProduct */
export async function deleteInsureProduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsureProductParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureMarketProduct/DeleteInsureProduct', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取市场保险产品配置列表 GET /api/InsureMarketProduct/GetInsureMarketProductSettingList */
export async function getInsureMarketProductSettingList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureMarketProductSettingListParams,
  options?: API.RequestConfig
) {
  return request<API.InsureMarketProductMainInfoDto>(
    '/api/InsureMarketProduct/GetInsureMarketProductSettingList',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取保险产品所有的列表 POST /api/InsureMarketProduct/GetInsureProductAllList */
export async function getInsureProductAllList(
  body: API.GetInsureMarketProductAllInput,
  options?: API.RequestConfig
) {
  return request<API.InsureMarketProductAllDto[]>(
    '/api/InsureMarketProduct/GetInsureProductAllList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 根据ID 获取保险详情 GET /api/InsureMarketProduct/GetInsureProductInfoById */
export async function getInsureProductInfoById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureProductInfoByIdParams,
  options?: API.RequestConfig
) {
  return request<API.InsureMarketProductInfoDto>(
    '/api/InsureMarketProduct/GetInsureProductInfoById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取保险后端列表 POST /api/InsureMarketProduct/GetInsureProductList */
export async function getInsureProductList(
  body: API.GetInsureMarketProductInput,
  options?: API.RequestConfig
) {
  return request<API.InsureMarketProductDtoPageOutput>(
    '/api/InsureMarketProduct/GetInsureProductList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取保险的商城列表 POST /api/InsureMarketProduct/GetInsureProductListForFront */
export async function getInsureProductListForFront(
  body: API.GetInsureMarketProductInput,
  options?: API.RequestConfig
) {
  return request<API.InsureMarketProductForFrontDtoPageOutput>(
    '/api/InsureMarketProduct/GetInsureProductListForFront',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取市场产品单价 POST /api/InsureMarketProduct/GetMarketProductPrice */
export async function getMarketProductPrice(
  body: API.GetMarketProductPriceInput,
  options?: API.RequestConfig
) {
  return request<API.GetMarketProductPriceDto>('/api/InsureMarketProduct/GetMarketProductPrice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取禁止投保城市 POST /api/InsureMarketProduct/GetNoAllowInsureCityList */
export async function getNoAllowInsureCityList(
  body: API.CheckInsureCityIsAllowInput,
  options?: API.RequestConfig
) {
  return request<string[]>('/api/InsureMarketProduct/GetNoAllowInsureCityList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /api/InsureMarketProduct/GetUserCanAuthProductList */
export async function getUserCanAuthProductList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserCanAuthProductListParams,
  options?: API.RequestConfig
) {
  return request<API.GetCanAuthMarkProductOutput>(
    '/api/InsureMarketProduct/GetUserCanAuthProductList',
    {
      method: 'POST',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 产品对客户授权 POST /api/InsureMarketProduct/InsureMarketProductToAuth */
export async function insureMarketProductToAuth(
  body: API.InsureMarketProductToAuthInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureMarketProduct/InsureMarketProductToAuth', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 对保险进行配置 POST /api/InsureMarketProduct/InsureProductServerSetting */
export async function insureProductServerSetting(
  body: API.InsureMarkProductSettingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureMarketProduct/InsureProductServerSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置保险状态 POST /api/InsureMarketProduct/SetInsureProductStatus */
export async function setInsureProductStatus(
  body: API.SetProductStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureMarketProduct/SetInsureProductStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/InsureOfflineBill.ts

New file
@@ -0,0 +1,273 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增删除表单 POST /api/InsureOfflineBill/CreateOrEditInsureOfflineBill */
export async function createOrEditInsureOfflineBill(
  body: API.CreateOrEditInsureOfflineBillInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/InsureOfflineBill/CreateOrEditInsureOfflineBill', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除表单 DELETE /api/InsureOfflineBill/DeleteInsureProduct */
export async function deleteInsureProduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsureProductParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureOfflineBill/DeleteInsureProduct', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 批增---线下批增导出 POST /api/InsureOfflineBill/GeOfflineInsureBatchAddListExport */
export async function geOfflineInsureBatchAddListExport(
  body: API.BatchRefundInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/InsureOfflineBill/GeOfflineInsureBatchAddListExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 退保--线下退保导出 POST /api/InsureOfflineBill/GeOfflineInsureBatchRefundListExport */
export async function geOfflineInsureBatchRefundListExport(
  body: API.BatchRefundInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/InsureOfflineBill/GeOfflineInsureBatchRefundListExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 退保---线上退保导出 POST /api/InsureOfflineBill/GeOnlineInsureBatchRefundListExport */
export async function geOnlineInsureBatchRefundListExport(
  body: API.BatchRefundInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/InsureOfflineBill/GeOnlineInsureBatchRefundListExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 批增名单导出 POST /api/InsureOfflineBill/GetBatchAddInfoDetailExport */
export async function getBatchAddInfoDetailExport(
  body: API.BatchRefundInfoDetailInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/InsureOfflineBill/GetBatchAddInfoDetailExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 线下退保--退保名单 POST /api/InsureOfflineBill/GetBatchRefundInfoDetail */
export async function getBatchRefundInfoDetail(
  body: API.BatchRefundInfoDetailInput,
  options?: API.RequestConfig
) {
  return request<API.BatchRefundInfoDetailOutputPageOutput>(
    '/api/InsureOfflineBill/GetBatchRefundInfoDetail',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 退保名单导出 POST /api/InsureOfflineBill/GetBatchRefundInfoDetailExport */
export async function getBatchRefundInfoDetailExport(
  body: API.BatchRefundInfoDetailInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/InsureOfflineBill/GetBatchRefundInfoDetailExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 线下退保--获取退保名单 GET /api/InsureOfflineBill/GetInsureBatchStaff */
export async function getInsureBatchStaff(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureBatchStaffParams,
  options?: API.RequestConfig
) {
  return request<API.BatchRefundStaffOutput[]>('/api/InsureOfflineBill/GetInsureBatchStaff', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 保险管理列表导出 POST /api/InsureOfflineBill/GetInsureOfflineBillExportList */
export async function getInsureOfflineBillExportList(
  body: API.GetInsureOfflineBillExportInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/InsureOfflineBill/GetInsureOfflineBillExportList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取表单详情 GET /api/InsureOfflineBill/GetInsureOfflineBillInfoById */
export async function getInsureOfflineBillInfoById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureOfflineBillInfoByIdParams,
  options?: API.RequestConfig
) {
  return request<API.InsureOfflineBillInfoDto>(
    '/api/InsureOfflineBill/GetInsureOfflineBillInfoById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取线下表单列表 POST /api/InsureOfflineBill/GetInsureOfflineBillList */
export async function getInsureOfflineBillList(
  body: API.GetInsureOfflineBillInput,
  options?: API.RequestConfig
) {
  return request<API.InsureOfflineBillDtoPageOutput>(
    '/api/InsureOfflineBill/GetInsureOfflineBillList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 线下退保--详情表头 GET /api/InsureOfflineBill/GetOfflineInsureBatchRefundHead */
export async function getOfflineInsureBatchRefundHead(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOfflineInsureBatchRefundHeadParams,
  options?: API.RequestConfig
) {
  return request<API.BatchRefundInfoOutput>(
    '/api/InsureOfflineBill/GetOfflineInsureBatchRefundHead',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 线下退保--退保列表 POST /api/InsureOfflineBill/GetOfflineInsureBatchRefundList */
export async function getOfflineInsureBatchRefundList(
  body: API.BatchRefundInput,
  options?: API.RequestConfig
) {
  return request<API.BatchRefundOutputPageOutput>(
    '/api/InsureOfflineBill/GetOfflineInsureBatchRefundList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 线下退保--退保申请 POST /api/InsureOfflineBill/OfflineInsureBatchRefundApply */
export async function offlineInsureBatchRefundApply(
  body: API.OfflineInsureBatchRefundApplyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureOfflineBill/OfflineInsureBatchRefundApply', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 线下退保--退保审核 POST /api/InsureOfflineBill/OfflineInsureBatchRefundCheck */
export async function offlineInsureBatchRefundCheck(
  body: API.OfflineInsureBatchRefundCheckInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureOfflineBill/OfflineInsureBatchRefundCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置保单状态 POST /api/InsureOfflineBill/SeInsureOfflineBillStatus */
export async function seInsureOfflineBillStatus(
  body: API.SetOfflineBillStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureOfflineBill/SeInsureOfflineBillStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/InsureOrganization.ts

New file
@@ -0,0 +1,95 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增编辑保险机构 POST /api/InsureOrganization/CreateOrEditInsureOrganization */
export async function createOrEditInsureOrganization(
  body: API.CreateOrEditInsureOrganizationInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/InsureOrganization/CreateOrEditInsureOrganization', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除保险机构 DELETE /api/InsureOrganization/DeleteInsureOrganization */
export async function deleteInsureOrganization(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsureOrganizationParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureOrganization/DeleteInsureOrganization', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据ID获取保险机构详情 GET /api/InsureOrganization/GetInsureOrganizationInfoById */
export async function getInsureOrganizationInfoById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureOrganizationInfoByIdParams,
  options?: API.RequestConfig
) {
  return request<API.InsureOrganizationDto>(
    '/api/InsureOrganization/GetInsureOrganizationInfoById',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取保险机构列表 POST /api/InsureOrganization/GetInsureOrganizationList */
export async function getInsureOrganizationList(
  body: API.GetInsureOrganizationInput,
  options?: API.RequestConfig
) {
  return request<API.InsureOrganizationInfoDtoPageOutput>(
    '/api/InsureOrganization/GetInsureOrganizationList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取保险机构下拉列表 GET /api/InsureOrganization/GetInsureOrganizationListForSelect */
export async function getInsureOrganizationListForSelect(options?: API.RequestConfig) {
  return request<API.InsureOrganizationSelectDto[]>(
    '/api/InsureOrganization/GetInsureOrganizationListForSelect',
    {
      method: 'GET',
      ...(options || {}),
    }
  );
}

/** 设置状态 POST /api/InsureOrganization/SetInsureOrganizationStatus */
export async function setInsureOrganizationStatus(
  body: API.SetNormalStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureOrganization/SetInsureOrganizationStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/InsureSupplier.ts

New file
@@ -0,0 +1,96 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增编辑供应商 POST /api/InsureSupplier/CreateOrEditInsureSupplier */
export async function createOrEditInsureSupplier(
  body: API.CreateOrEditInsureSupplierInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/InsureSupplier/CreateOrEditInsureSupplier', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除供应商 DELETE /api/InsureSupplier/DeleteInsureSupplier */
export async function deleteInsureSupplier(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteInsureSupplierParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureSupplier/DeleteInsureSupplier', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据ID获取供应商详情 GET /api/InsureSupplier/GetInsureSupplierInfoById */
export async function getInsureSupplierInfoById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureSupplierInfoByIdParams,
  options?: API.RequestConfig
) {
  return request<API.InsureSupplierDto>('/api/InsureSupplier/GetInsureSupplierInfoById', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取供应商列表 POST /api/InsureSupplier/GetInsureSupplierList */
export async function getInsureSupplierList(
  body: API.GetInsureSupplierInput,
  options?: API.RequestConfig
) {
  return request<API.InsureSupplierDtoPageOutput>('/api/InsureSupplier/GetInsureSupplierList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取供应商的下拉选项 供应商类型 1渠道商 2保险公司 GET /api/InsureSupplier/GetInsureSupplierListForSelect */
export async function getInsureSupplierListForSelect(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetInsureSupplierListForSelectParams,
  options?: API.RequestConfig
) {
  return request<API.InsureSupplierSelectDto[]>(
    '/api/InsureSupplier/GetInsureSupplierListForSelect',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 设置状态 POST /api/InsureSupplier/SetInsureSupplierStatus */
export async function setInsureSupplierStatus(
  body: API.SetNormalStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/InsureSupplier/SetInsureSupplierStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/LgGigWorker.ts

New file
@@ -0,0 +1,579 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增编辑客户 POST /api/LgGigWorker/AddUpdateCustomer */
export async function addUpdateCustomer(
  body: API.AddUpdateCustomerInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/AddUpdateCustomer', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 运营端对客户新增编辑合同模板 POST /api/LgGigWorker/AddUpdateCustomerContractTemplate */
export async function addUpdateCustomerContractTemplate(
  body: API.AddUpdateContractTemplateInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/AddUpdateCustomerContractTemplate', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 客户新增编辑合同模板 POST /api/LgGigWorker/AddUpdateCustomerContractTemplateWithCustomer */
export async function addUpdateCustomerContractTemplateWithCustomer(
  body: API.AddUpdateContractTemplateInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/AddUpdateCustomerContractTemplateWithCustomer', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 判断是否能签署 GET /api/LgGigWorker/CanSign */
export async function canSign(options?: API.RequestConfig) {
  return request<boolean>('/api/LgGigWorker/CanSign', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取人员实名认证状态 POST /api/LgGigWorker/CheckUserRealVerifyStatus */
export async function checkUserRealVerifyStatus(
  body: API.LgGigWorkerBaseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/CheckUserRealVerifyStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除合同模板 DELETE /api/LgGigWorker/DeleteCustomerTemplate */
export async function deleteCustomerTemplate(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteCustomerTemplateParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/DeleteCustomerTemplate', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除用户 DELETE /api/LgGigWorker/DeleteLgGigWorkerUser */
export async function deleteLgGigWorkerUser(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteLgGigWorkerUserParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/DeleteLgGigWorkerUser', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 费用扣除 GET /api/LgGigWorker/DoDeductAmountForSignCost */
export async function doDeductAmountForSignCost(options?: API.RequestConfig) {
  return request<number>('/api/LgGigWorker/DoDeductAmountForSignCost', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 下载合同凭证 GET /api/LgGigWorker/DoDownloadContractAttachmentFile */
export async function doDownloadContractAttachmentFile(options?: API.RequestConfig) {
  return request<number>('/api/LgGigWorker/DoDownloadContractAttachmentFile', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 下载合同 GET /api/LgGigWorker/DoDownloadContractFile */
export async function doDownloadContractFile(options?: API.RequestConfig) {
  return request<number>('/api/LgGigWorker/DoDownloadContractFile', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取当前电子签类型 GET /api/LgGigWorker/GetCurrentSignType */
export async function getCurrentSignType(options?: API.RequestConfig) {
  return request<string>('/api/LgGigWorker/GetCurrentSignType', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取甲方列表 POST /api/LgGigWorker/GetCustomerList */
export async function getCustomerList(body: API.GetCustomerListInput, options?: API.RequestConfig) {
  return request<API.GetCustomerListOutputPageOutput>('/api/LgGigWorker/GetCustomerList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取模板明细信息 GET /api/LgGigWorker/GetCustomerTemplateDetail */
export async function getCustomerTemplateDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCustomerTemplateDetailParams,
  options?: API.RequestConfig
) {
  return request<API.GetCustomerTemplateDetailOutput>(
    '/api/LgGigWorker/GetCustomerTemplateDetail',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取甲方客户合同模板列表 GET /api/LgGigWorker/GetCustomerTemplateList */
export async function getCustomerTemplateList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCustomerTemplateListParams,
  options?: API.RequestConfig
) {
  return request<API.GetCustomerTemplateListOutput[]>('/api/LgGigWorker/GetCustomerTemplateList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取甲方客户合同模板列表 POST /api/LgGigWorker/GetCustomerTemplateList */
export async function getCustomerTemplateList_2(
  body: API.QueryCustomerTemplateListInput,
  options?: API.RequestConfig
) {
  return request<API.GetCustomerTemplateListOutput[]>('/api/LgGigWorker/GetCustomerTemplateList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取企业费用统计 GET /api/LgGigWorker/GetEnterinessLgGigSignFee */
export async function getEnterinessLgGigSignFee(options?: API.RequestConfig) {
  return request<API.EnterinessLgGigSignFeeOutput>('/api/LgGigWorker/GetEnterinessLgGigSignFee', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取合同地址 POST /api/LgGigWorker/GetLgGigWorkerContractUrl */
export async function getLgGigWorkerContractUrl(
  body: API.LgGigWorkerBaseInput,
  options?: API.RequestConfig
) {
  return request<API.GetLgGigWorkerContractUrlOutput>(
    '/api/LgGigWorker/GetLgGigWorkerContractUrl',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取合同预览地址 POST /api/LgGigWorker/GetLgGigWorkerPriviewUrl */
export async function getLgGigWorkerPriviewUrl(
  body: API.UserGetSignPriveiwUrlInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/LgGigWorker/GetLgGigWorkerPriviewUrl', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取人员信息 GET /api/LgGigWorker/GetLgGigWorkUserDetail */
export async function getLgGigWorkUserDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetLgGigWorkUserDetailParams,
  options?: API.RequestConfig
) {
  return request<API.LgGigWorkUserOutput>('/api/LgGigWorker/GetLgGigWorkUserDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取C端人员管理列表 POST /api/LgGigWorker/GetLgGigWorkUserList */
export async function getLgGigWorkUserList(
  body: API.GetLgGigWorkUserInput,
  options?: API.RequestConfig
) {
  return request<API.LgGigWorkUserOutputPageOutput>('/api/LgGigWorker/GetLgGigWorkUserList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 根据bussinessCode获取其电子签通道 GET /api/LgGigWorker/GetSignChannelByBussinessCode */
export async function getSignChannelByBussinessCode(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetSignChannelByBussinessCodeParams,
  options?: API.RequestConfig
) {
  return request<API.SignChannelEnum>('/api/LgGigWorker/GetSignChannelByBussinessCode', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据signId获取其电子签通道 GET /api/LgGigWorker/GetSignChannelBySignId */
export async function getSignChannelBySignId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetSignChannelBySignIdParams,
  options?: API.RequestConfig
) {
  return request<API.SignChannelEnum>('/api/LgGigWorker/GetSignChannelBySignId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取统一电子签费用 POST /api/LgGigWorker/GetSignMergeSignCostList */
export async function getSignMergeSignCostList(
  body: API.GetSignCostListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSignMergeCostListOutputPageOutput>(
    '/api/LgGigWorker/GetSignMergeSignCostList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取短信费用 POST /api/LgGigWorker/GetSignMessgeCostList */
export async function getSignMessgeCostList(
  body: API.GetSignCostListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSignMessageCostListOutputPageOutput>(
    '/api/LgGigWorker/GetSignMessgeCostList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取实名认证费用 POST /api/LgGigWorker/GetSignRealNameCostList */
export async function getSignRealNameCostList(
  body: API.GetSignCostListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSignRealNameCostListOutputPageOutput>(
    '/api/LgGigWorker/GetSignRealNameCostList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 根据signChannel获取计费方式 GET /api/LgGigWorker/GetSignSettingByChannle */
export async function getSignSettingByChannle(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetSignSettingByChannleParams,
  options?: API.RequestConfig
) {
  return request<API.ChargeTypeEnum>('/api/LgGigWorker/GetSignSettingByChannle', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取客户甲方下拉列表 GET /api/LgGigWorker/GetUserCustomerAllList */
export async function getUserCustomerAllList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserCustomerAllListParams,
  options?: API.RequestConfig
) {
  return request<API.GetCustomerListOutput[]>('/api/LgGigWorker/GetUserCustomerAllList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 人员导入 POST /api/LgGigWorker/ImportLgGigWorkerUser */
export async function importLgGigWorkerUser(
  body: API.LgGigWorkerUserImport,
  options?: API.RequestConfig
) {
  return request<API.ImportInsLgWorkerOutput>('/api/LgGigWorker/ImportLgGigWorkerUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取签约链接 POST /api/LgGigWorker/LgGigUserToSignUrl */
export async function lgGigUserToSignUrl(
  body: API.LgGigUserToSignUrlInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/LgGigWorker/LgGigUserToSignUrl', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 自动签署 POST /api/LgGigWorker/LgGigWorkerBussinessAutoSign */
export async function lgGigWorkerBussinessAutoSign(
  body: API.LgGigWorkerBussinessAutoSignInput,
  options?: API.RequestConfig
) {
  return request<API.LgGigWorkerBussinessAutoSignOutput>(
    '/api/LgGigWorker/LgGigWorkerBussinessAutoSign',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 灵工人员登记 POST /api/LgGigWorker/LgGigWorkerRegister */
export async function lgGigWorkerRegister(
  body: API.LgGigWorkerRegisterInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/LgGigWorker/LgGigWorkerRegister', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 记录费用 POST /api/LgGigWorker/RecordUserSignCost */
export async function recordUserSignCost(
  body: API.RecordUserSignInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/RecordUserSignCost', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** C端用户批量短信发送 POST /api/LgGigWorker/SendMessageForSign */
export async function sendMessageForSign(
  body: API.LgGigWorkerUserSignListInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/SendMessageForSign', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 插入多合同手动签章Key POST /api/LgGigWorker/SetManyContractHandSignKey */
export async function setManyContractHandSignKey(
  body: API.SetManyContractTemplateHandSignKeyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/SetManyContractHandSignKey', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 插入多合同自动签使用坐标 POST /api/LgGigWorker/SetManyContractTemplatePosition */
export async function setManyContractTemplatePosition(
  body: API.SetContractTemplatePositionInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/SetManyContractTemplatePosition', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 合同下载 POST /api/LgGigWorker/SignOverDownlaodContract */
export async function signOverDownlaodContract(
  body: API.GetUserStorageContractUploadResponse,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/LgGigWorker/SignOverDownlaodContract', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新人员信息 POST /api/LgGigWorker/UpdateLgGigWorkerUserInfo */
export async function updateLgGigWorkerUserInfo(
  body: API.UpdateLgGigWorkerUserInfoInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/UpdateLgGigWorkerUserInfo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户解约 POST /api/LgGigWorker/UpdateLgGigWorkerUserSignStatus */
export async function updateLgGigWorkerUserSignStatus(
  body: API.LgGigWorkerUserSignListInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorker/UpdateLgGigWorkerUserSignStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 人员认证前发送短信验证码 POST /api/LgGigWorker/UserGoToContactSignVerify */
export async function userGoToContactSignVerify(
  body: API.UserGetSignPriveiwUrlInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>('/api/LgGigWorker/UserGoToContactSignVerify', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** C端人员认证并获取证书 POST /api/LgGigWorker/UserPersonalRegAndRealNameAndApplyCert */
export async function userPersonalRegAndRealNameAndApplyCert(
  body: API.UserPersonRealVerifyInput,
  options?: API.RequestConfig
) {
  return request<API.BestSignRequestResultDto>(
    '/api/LgGigWorker/UserPersonalRegAndRealNameAndApplyCert',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/LgGigWorkerCustomerTemplateParam.ts

New file
@@ -0,0 +1,65 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 添加系统 模板数据参数字典 POST /api/LgGigWorkerCustomerTemplateParam/AddSystemTemplateDataParamSetting */
export async function addSystemTemplateDataParamSetting(
  body: API.AddSystemTemplateDataParamSettingInput,
  options?: API.RequestConfig
) {
  return request<number>(
    '/api/LgGigWorkerCustomerTemplateParam/AddSystemTemplateDataParamSetting',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取所有系统 模板数据参数字典 POST /api/LgGigWorkerCustomerTemplateParam/GetAllSystemTemplateDataParamSettingList */
export async function getAllSystemTemplateDataParamSettingList(options?: API.RequestConfig) {
  return request<API.SystemTemplateDataParamSettingOutput[]>(
    '/api/LgGigWorkerCustomerTemplateParam/GetAllSystemTemplateDataParamSettingList',
    {
      method: 'POST',
      ...(options || {}),
    }
  );
}

/** 根据模板id获取模板参数列表 POST /api/LgGigWorkerCustomerTemplateParam/GetCustomerTemplateParamListByTemplateId */
export async function getCustomerTemplateParamListByTemplateId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCustomerTemplateParamListByTemplateIdParams,
  options?: API.RequestConfig
) {
  return request<API.CustomerTemplateParamListOutput[]>(
    '/api/LgGigWorkerCustomerTemplateParam/GetCustomerTemplateParamListByTemplateId',
    {
      method: 'POST',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 保存模板参数 POST /api/LgGigWorkerCustomerTemplateParam/SaveCustomerTemplateParam */
export async function saveCustomerTemplateParam(
  body: API.SaveCustomerTemplateParamInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorkerCustomerTemplateParam/SaveCustomerTemplateParam', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/LgGigWorkerReCharge.ts

New file
@@ -0,0 +1,77 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 电子签费用充值 POST /api/LgGigWorkerReCharge/ApplyGigWorkerRechargeFee */
export async function applyGigWorkerRechargeFee(
  body: API.ApplyGigWorkerRechargeFeeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorkerReCharge/ApplyGigWorkerRechargeFee', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 电子签充值审核 POST /api/LgGigWorkerReCharge/AuditGigWorkerRechargeFee */
export async function auditGigWorkerRechargeFee(
  body: API.AuditGigWorkerRechargeFeeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorkerReCharge/AuditGigWorkerRechargeFee', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取电子签详情 GET /api/LgGigWorkerReCharge/GetGigWorkerRechargeFeeDetail */
export async function getGigWorkerRechargeFeeDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetGigWorkerRechargeFeeDetailParams,
  options?: API.RequestConfig
) {
  return request<API.GigWorkerRechargeFeeOutput>(
    '/api/LgGigWorkerReCharge/GetGigWorkerRechargeFeeDetail',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取电子签充值列表 POST /api/LgGigWorkerReCharge/GetGigWorkerRechargeFeeList */
export async function getGigWorkerRechargeFeeList(
  body: API.GetGigWorkerRechargeFeeInput,
  options?: API.RequestConfig
) {
  return request<API.GigWorkerRechargeFeeOutputPageOutput>(
    '/api/LgGigWorkerReCharge/GetGigWorkerRechargeFeeList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取费用充值配置 GET /api/LgGigWorkerReCharge/GetLgGigWorkerSignOptions */
export async function getLgGigWorkerSignOptions(options?: API.RequestConfig) {
  return request<API.LgGigWorkerSignOptions>('/api/LgGigWorkerReCharge/GetLgGigWorkerSignOptions', {
    method: 'GET',
    ...(options || {}),
  });
}

 src/services/api/LgGigWorkerSignChannelSetting.ts

New file
@@ -0,0 +1,72 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

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

/** 删除渠道配置管理 DELETE /api/LgGigWorkerSignChannelSetting/DeleteLgGigWorkerSignChannelSetting */
export async function deleteLgGigWorkerSignChannelSetting(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteLgGigWorkerSignChannelSettingParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorkerSignChannelSetting/DeleteLgGigWorkerSignChannelSetting', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取渠道管理列表 POST /api/LgGigWorkerSignChannelSetting/GetLgGigWorkerSignChannelSettingList */
export async function getLgGigWorkerSignChannelSettingList(
  body: API.GetGigWorkerSignChannelSettingInput,
  options?: API.RequestConfig
) {
  return request<API.LgGigWorkerSignChannelSettingDtoPageOutput>(
    '/api/LgGigWorkerSignChannelSetting/GetLgGigWorkerSignChannelSettingList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 设置配置状态 POST /api/LgGigWorkerSignChannelSetting/SetLgGigWorkerSignChannelSettingStatus */
export async function setLgGigWorkerSignChannelSettingStatus(
  body: API.SetSignChannelStatusInput,
  options?: API.RequestConfig
) {
  return request<number>(
    '/api/LgGigWorkerSignChannelSetting/SetLgGigWorkerSignChannelSettingStatus',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/LgGigWorkerSignFreeSetting.ts

New file
@@ -0,0 +1,62 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增修改电子签赠送管理 POST /api/LgGigWorkerSignFreeSetting/CreateOrEditLgGigWorkerSignFreeSetting */
export async function createOrEditLgGigWorkerSignFreeSetting(
  body: API.CreateOrEditLgGigWorkerSignFreeSettingInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/LgGigWorkerSignFreeSetting/CreateOrEditLgGigWorkerSignFreeSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除电子签赠送管理 DELETE /api/LgGigWorkerSignFreeSetting/DeleteLgGigWorkerSignFreeSetting */
export async function deleteLgGigWorkerSignFreeSetting(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteLgGigWorkerSignFreeSettingParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorkerSignFreeSetting/DeleteLgGigWorkerSignFreeSetting', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取电子签通道 GET /api/LgGigWorkerSignFreeSetting/GetLgGigWorkerSignChannel */
export async function getLgGigWorkerSignChannel(options?: API.RequestConfig) {
  return request<API.LgGigWorkerSignChannelDto[]>(
    '/api/LgGigWorkerSignFreeSetting/GetLgGigWorkerSignChannel',
    {
      method: 'GET',
      ...(options || {}),
    }
  );
}

/** 获取电子签赠送管理列表 POST /api/LgGigWorkerSignFreeSetting/GetLgGigWorkerSignFreeSettingList */
export async function getLgGigWorkerSignFreeSettingList(
  body: API.GetGigWorkerSignFreeSettingInput,
  options?: API.RequestConfig
) {
  return request<API.LgGigWorkerSignFreeSettingDtoPageOutput>(
    '/api/LgGigWorkerSignFreeSetting/GetLgGigWorkerSignFreeSettingList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/LgGigWorkerSignSetting.ts

New file
@@ -0,0 +1,66 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增或修改电子签设置 POST /api/LgGigWorkerSignSetting/CreateOrEditLgGigWorkerSignSetting */
export async function createOrEditLgGigWorkerSignSetting(
  body: API.CreateOrEditLgGigWorkerSignSettingInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/LgGigWorkerSignSetting/CreateOrEditLgGigWorkerSignSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除电子签设置 DELETE /api/LgGigWorkerSignSetting/DeleteLgGigWorkerSignSetting */
export async function deleteLgGigWorkerSignSetting(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteLgGigWorkerSignSettingParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorkerSignSetting/DeleteLgGigWorkerSignSetting', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取电子签配置管理列表 POST /api/LgGigWorkerSignSetting/GetLgGigWorkerSignSettingList */
export async function getLgGigWorkerSignSettingList(
  body: API.GetGigWorkerSignSettingInput,
  options?: API.RequestConfig
) {
  return request<API.LgGigWorkerSignSettingDtoPageOutput>(
    '/api/LgGigWorkerSignSetting/GetLgGigWorkerSignSettingList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 设置电子签设置状态 POST /api/LgGigWorkerSignSetting/SetLgGigWorkerSignSettingStatus */
export async function setLgGigWorkerSignSettingStatus(
  body: API.SetSignStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/LgGigWorkerSignSetting/SetLgGigWorkerSignSettingStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Message.ts

New file
@@ -0,0 +1,266 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取个人中心的消息列表 POST /api/Message/GetMessageListForPersonal */
export async function getMessageListForPersonal(
  body: API.GetMessageInput,
  options?: API.RequestConfig
) {
  return request<API.MessageInfoPageOutput>('/api/Message/GetMessageListForPersonal', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的新增关注消息分页列表 POST /api/Message/GetMyAddFollowMessagePage */
export async function getMyAddFollowMessagePage(body: API.PageInput, options?: API.RequestConfig) {
  return request<API.AddFollowMessageInfoPageOutput>('/api/Message/GetMyAddFollowMessagePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的基础会话 POST /api/Message/GetMyBaseChatList */
export async function getMyBaseChatList(options?: API.RequestConfig) {
  return request<API.MassgeChatOutput[]>('/api/Message/GetMyBaseChatList', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 获取我的会话消息分页列表 POST /api/Message/GetMyChatMessagePage */
export async function getMyChatMessagePage(
  body: API.QueryMyMessageInput,
  options?: API.RequestConfig
) {
  return request<API.UserMessageInfoPageOutput>('/api/Message/GetMyChatMessagePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的好友消息会话分页列表 POST /api/Message/GetMyFriendChatPage */
export async function getMyFriendChatPage(body: API.GetMessageInput, options?: API.RequestConfig) {
  return request<API.MassgeChatOutputPageOutput>('/api/Message/GetMyFriendChatPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的好友消息分页列表 POST /api/Message/GetMyFriendMessagePage */
export async function getMyFriendMessagePage(
  body: API.QueryMyMessageInput,
  options?: API.RequestConfig
) {
  return request<API.UserMessageInfoPageOutput>('/api/Message/GetMyFriendMessagePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的赞和收藏及新增关注的消息总数 POST /api/Message/GetMyLikeFavoriteAddFollowMessageCount */
export async function getMyLikeFavoriteAddFollowMessageCount(options?: API.RequestConfig) {
  return request<API.MyLikeFavoriteAddFollowMessageCountOutput>(
    '/api/Message/GetMyLikeFavoriteAddFollowMessageCount',
    {
      method: 'POST',
      ...(options || {}),
    }
  );
}

/** 获取我的点赞收藏消息分页列表 POST /api/Message/GetMyLikeFavoriteMessagePage */
export async function getMyLikeFavoriteMessagePage(
  body: API.PageInput,
  options?: API.RequestConfig
) {
  return request<API.LikeFavoriteMessageInfoPageOutput>(
    '/api/Message/GetMyLikeFavoriteMessagePage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取我的消息总数 GET /api/Message/GetMyMessageCount */
export async function getMyMessageCount(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetMyMessageCountParams,
  options?: API.RequestConfig
) {
  return request<API.MyMessageCountOutput>('/api/Message/GetMyMessageCount', {
    method: 'GET',
    params: {
      // isContainLikeFavoriteAddFollowMessageCount has a default value: true
      isContainLikeFavoriteAddFollowMessageCount: 'true',
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取未读消息数 GET /api/Message/GetMyMessageTotal */
export async function getMyMessageTotal(options?: API.RequestConfig) {
  return request<number>('/api/Message/GetMyMessageTotal', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取我的系统消息分页列表 POST /api/Message/GetMySystemMessagePage */
export async function getMySystemMessagePage(
  body: API.GetMessageInput,
  options?: API.RequestConfig
) {
  return request<API.MessageInfoPageOutput>('/api/Message/GetMySystemMessagePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的陌生人消息会话分页列表 POST /api/Message/GetMyUnfamiliarChatPage */
export async function getMyUnfamiliarChatPage(
  body: API.GetMessageInput,
  options?: API.RequestConfig
) {
  return request<API.MassgeChatOutputPageOutput>('/api/Message/GetMyUnfamiliarChatPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的陌生人消息分页列表 POST /api/Message/GetMyUnfamiliarMessagePage */
export async function getMyUnfamiliarMessagePage(
  body: API.QueryMyMessageInput,
  options?: API.RequestConfig
) {
  return request<API.UserMessageInfoPageOutput>('/api/Message/GetMyUnfamiliarMessagePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询钱包 交易相关消息 POST /api/Message/GetWalletMessageList */
export async function getWalletMessageList(body: API.GetMessageInput, options?: API.RequestConfig) {
  return request<API.MessageInfoPageOutput>('/api/Message/GetWalletMessageList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/Message/SendMessage */
export async function sendMessage(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIsendMessageParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Message/SendMessage', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 发送用户消息 POST /api/Message/SendUserMessage */
export async function sendUserMessage(
  body: API.UserTextChatMessageInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Message/SendUserMessage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新消息全部已读 GET /api/Message/SetAllMessageIsRead */
export async function setAllMessageIsRead(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIsetAllMessageIsReadParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Message/SetAllMessageIsRead', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据chatType设置所有消息为已读 POST /api/Message/SetAllMessageIsReadByChatType */
export async function setAllMessageIsReadByChatType(
  body: API.MessageChatTypeEnum,
  options?: API.RequestConfig
) {
  return request<number>('/api/Message/SetAllMessageIsReadByChatType', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新消息的阅读状态 GET /api/Message/SetMessageIsRead */
export async function setMessageIsRead(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIsetMessageIsReadParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Message/SetMessageIsRead', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

 src/services/api/OpenInformation.ts

New file
@@ -0,0 +1,44 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 此处后端没有提供注释 POST /api/OpenInformation/UploadInformation */
export async function uploadInformation(
  body: {
    /** 密钥 */
    Secret?: string;
    /** 标题 */
    Title?: string;
    /** 作者 */
    Author?: string;
    /** 正文 */
    Body?: string;
    /** 栏目Id */
    TypeId?: string;
    /** 封面 */
    CoverInfo?: string;
    /** 采集的源地址 */
    AcquisitionSourceLink?: string;
  },
  options?: API.RequestConfig
) {
  const formData = new FormData();

  Object.keys(body).forEach((ele) => {
    const item = (body as any)[ele];

    if (item !== undefined && item !== null) {
      formData.append(
        ele,
        typeof item === 'object' && !(item instanceof File) ? JSON.stringify(item) : item
      );
    }
  });

  return request<number>('/api/OpenInformation/UploadInformation', {
    method: 'POST',
    data: formData,
    requestType: 'form',
    ...(options || {}),
  });
}

 src/services/api/OperateHistory.ts

New file
@@ -0,0 +1,36 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 查询日志 POST /api/OperateHistory/GetOperateHistoryByRelationId */
export async function getOperateHistoryByRelationId(
  body: API.GetOperateHistoryInput,
  options?: API.RequestConfig
) {
  return request<API.OperateHistoryDtoPageOutput>(
    '/api/OperateHistory/GetOperateHistoryByRelationId',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 根据type查询日志 POST /api/OperateHistory/GetOperateHistoryByType */
export async function getOperateHistoryByType(
  body: API.QueryOperateHistoryByTypeInput,
  options?: API.RequestConfig
) {
  return request<API.OperateHistoryDtoPageOutput>('/api/OperateHistory/GetOperateHistoryByType', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Order.ts

New file
@@ -0,0 +1,408 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增联系记录 POST /api/Order/AddTradeChatRecord */
export async function addTradeChatRecord(
  body: API.AddTradeChatRecordInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/AddTradeChatRecord', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 交易申请 POST /api/Order/ApplyMatchMaking */
export async function applyMatchMaking(
  body: API.ApplyMatchMakingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/ApplyMatchMaking', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

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

/** 订单审核 POST /api/Order/CheckOrder */
export async function checkOrder(body: API.CreateOrUpdateOrderinput, options?: API.RequestConfig) {
  return request<string>('/api/Order/CheckOrder', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增修改订单 POST /api/Order/CreateOrUpdateOrder */
export async function createOrUpdateOrder(
  body: API.CreateOrUpdateOrderinput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Order/CreateOrUpdateOrder', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除交易申请 GET /api/Order/DeleteMatchMakingApply */
export async function deleteMatchMakingApply(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteMatchMakingApplyParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/DeleteMatchMakingApply', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除订单 GET /api/Order/DeleteOrder */
export async function deleteOrder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteOrderParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/DeleteOrder', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取甲方公司我要人列表 POST /api/Order/GetFirstPartyCompanyOrderList */
export async function getFirstPartyCompanyOrderList(
  body: API.OrderListInput,
  options?: API.RequestConfig
) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetFirstPartyCompanyOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

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

/** 根据订单获取交易申请分页列表 POST /api/Order/GetMatchMakingApplyByOrderPage */
export async function getMatchMakingApplyByOrderPage(
  body: API.QueryMatchMakingApplyByOrderInput,
  options?: API.RequestConfig
) {
  return request<API.MatchMakingApplyByOrderOutputPageOutput>(
    '/api/Order/GetMatchMakingApplyByOrderPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取我的甲方公司我要人列表 POST /api/Order/GetMyFirstPartyCompanyOrderList */
export async function getMyFirstPartyCompanyOrderList(
  body: API.OrderListInput,
  options?: API.RequestConfig
) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetMyFirstPartyCompanyOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的交易申请分页列表 POST /api/Order/GetMyMatchMakingApplyPage */
export async function getMyMatchMakingApplyPage(
  body: API.MyMatchMakingApplyInput,
  options?: API.RequestConfig
) {
  return request<API.MyMatchMakingApplyOutputPageOutput>('/api/Order/GetMyMatchMakingApplyPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询我的订单 POST /api/Order/GetMyOrderList */
export async function getMyOrderList(body: API.MyOrderListInput, options?: API.RequestConfig) {
  return request<API.FrontOrderListPageOutput>('/api/Order/GetMyOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取订单详情 GET /api/Order/GetOrdeForDetail */
export async function getOrdeForDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOrdeForDetailParams,
  options?: API.RequestConfig
) {
  return request<API.OrderInfoDto>('/api/Order/GetOrdeForDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据UserID获取订单详情 GET /api/Order/GetOrdeForDetailByUserId */
export async function getOrdeForDetailByUserId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOrdeForDetailByUserIdParams,
  options?: API.RequestConfig
) {
  return request<API.OrderInfoDto>('/api/Order/GetOrdeForDetailByUserId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取订单列表 POST /api/Order/GetOrderList */
export async function getOrderList(body: API.OrderListInput, options?: API.RequestConfig) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取订单审核列表 POST /api/Order/GetOrderListForCheck */
export async function getOrderListForCheck(body: API.OrderListInput, options?: API.RequestConfig) {
  return request<API.OrderListDtoPageOutput>('/api/Order/GetOrderListForCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取订单推荐列表 GET /api/Order/GetOrderListForRecommend */
export async function getOrderListForRecommend(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetOrderListForRecommendParams,
  options?: API.RequestConfig
) {
  return request<API.OrderListDto[]>('/api/Order/GetOrderListForRecommend', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取联系记录 POST /api/Order/GetTradeChatRecordPage */
export async function getTradeChatRecordPage(
  body: API.QueryTradeChatRecordInput,
  options?: API.RequestConfig
) {
  return request<API.TradeChatRecordOutputPageOutput>('/api/Order/GetTradeChatRecordPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取他人用户订单列表 POST /api/Order/GetUserOrderList */
export async function getUserOrderList(body: API.UserOrderListInput, options?: API.RequestConfig) {
  return request<API.FrontOrderListPageOutput>('/api/Order/GetUserOrderList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 订单收藏 POST /api/Order/OrderAttention */
export async function orderAttention(body: API.OrderViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/OrderAttention', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 订单浏览 POST /api/Order/OrderBrowse */
export async function orderBrowse(body: API.OrderViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/OrderBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 接单未读数 GET /api/Order/OrderTakenNotReadCount */
export async function orderTakenNotReadCount(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIorderTakenNotReadCountParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/OrderTakenNotReadCount', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 阅读接单信息 POST /api/Order/ReadOrderTaken */
export async function readOrderTaken(body: API.ReadOrderTakenInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/ReadOrderTaken', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 批量设置order状态 POST /api/Order/SetListOrderStatus */
export async function setListOrderStatus(body: API.ListOrderStatus, options?: API.RequestConfig) {
  return request<number>('/api/Order/SetListOrderStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置交易申请状态 POST /api/Order/SetMatchMakingApplyStatus */
export async function setMatchMakingApplyStatus(
  body: API.SetMatchMakingApplyStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/SetMatchMakingApplyStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置订单推荐 POST /api/Order/SetOrderRecommend */
export async function setOrderRecommend(
  body: API.ResourceRecommendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/SetOrderRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 订单招聘 上架/下架/修改状态/删除 POST /api/Order/SetOrderStatus */
export async function setOrderStatus(body: API.PutOrOffOrderInput, options?: API.RequestConfig) {
  return request<number>('/api/Order/SetOrderStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 我要接单 GET /api/Order/TakeOrder */
export async function takeOrder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItakeOrderParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Order/TakeOrder', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

 src/services/api/ParkOrHR.ts

New file
@@ -0,0 +1,408 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 上架广告信息 GET /api/ParkOrHR/AdvertiseOffShelf */
export async function advertiseOffShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertiseOffShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkOrHR/AdvertiseOffShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 下架广告信息 GET /api/ParkOrHR/AdvertiseOnShelf */
export async function advertiseOnShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertiseOnShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkOrHR/AdvertiseOnShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 关注园区或人资企业 GET /api/ParkOrHR/AttentOrNot */
export async function attentOrNot(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIattentOrNotParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkOrHR/AttentOrNot', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 审核人资公司 POST /api/ParkOrHR/CheckParkOrHRAudit */
export async function checkParkOrHRAudit(
  body: API.CreateOrEditParkOrHRAuditInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkOrHR/CheckParkOrHRAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建园区或人资企业 POST /api/ParkOrHR/CreateOrEditParkOrHR */
export async function createOrEditParkOrHR(
  body: API.CreateOrEditParkOrHRInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/ParkOrHR/CreateOrEditParkOrHR', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建或修改人资公司信息，走正常审核流程 POST /api/ParkOrHR/CreateOrEditParkOrHRWithAudit */
export async function createOrEditParkOrHRWithAudit(
  body: API.CreateOrEditParkOrHRInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/ParkOrHR/CreateOrEditParkOrHRWithAudit', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建广告信息 POST /api/ParkOrHR/CreateParkOrHRAdvertise */
export async function createParkOrHRAdvertise(
  body: API.CreateParkOrHRAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/ParkOrHR/CreateParkOrHRAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /api/ParkOrHR/GetAllParkOrHRList */
export async function getAllParkOrHRList(body: API.ParkHRInput, options?: API.RequestConfig) {
  return request<API.ParkOrHRList[]>('/api/ParkOrHR/GetAllParkOrHRList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取行业机构园区列表 POST /api/ParkOrHR/GetIndustryBodyParkOrHRList */
export async function getIndustryBodyParkOrHRList(
  body: API.ParkHRInput,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRListPageOutput>('/api/ParkOrHR/GetIndustryBodyParkOrHRList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/ParkOrHR/GetLock */
export async function getLock(options?: API.RequestConfig) {
  return request<number>('/api/ParkOrHR/GetLock', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取最大广告序列 GET /api/ParkOrHR/GetMaxAdvertiseSequence */
export async function getMaxAdvertiseSequence(options?: API.RequestConfig) {
  return request<number>('/api/ParkOrHR/GetMaxAdvertiseSequence', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取我的关注 POST /api/ParkOrHR/GetMyAttentions */
export async function getMyAttentions(body: API.GetMyAttentionsInput, options?: API.RequestConfig) {
  return request<API.ParkOrHRDtoPageOutput>('/api/ParkOrHR/GetMyAttentions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取当前客户的人资公司信息(当有在审或驳回的审核信息时返回审核信息) GET /api/ParkOrHR/GetMyParkOrHRInfo */
export async function getMyParkOrHRInfo(options?: API.RequestConfig) {
  return request<API.MyParkOrHRInfoDto>('/api/ParkOrHR/GetMyParkOrHRInfo', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取园区客户 POST /api/ParkOrHR/GetParkCustomerList */
export async function getParkCustomerList(
  body: API.FrontHROfParkInput,
  options?: API.RequestConfig
) {
  return request<API.FrontHROfParkListPageOutput>('/api/ParkOrHR/GetParkCustomerList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取广告信息 GET /api/ParkOrHR/GetParkOrHRAdvertise */
export async function getParkOrHRAdvertise(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetParkOrHRAdvertiseParams,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRAdvertiseInfo>('/api/ParkOrHR/GetParkOrHRAdvertise', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取推荐园区信息 POST /api/ParkOrHR/GetParkOrHRAdvertiseForRecommend */
export async function getParkOrHRAdvertiseForRecommend(
  body: API.ParkHRForHomePageInput,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRDetailPageOutput>('/api/ParkOrHR/GetParkOrHRAdvertiseForRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取人资公司审核详情信息 GET /api/ParkOrHR/GetParkOrHRAuditInfoById */
export async function getParkOrHRAuditInfoById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetParkOrHRAuditInfoByIdParams,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRAuditInfoDto>('/api/ParkOrHR/GetParkOrHRAuditInfoById', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取人资公司审核分页列表 POST /api/ParkOrHR/GetParkOrHRAuditPage */
export async function getParkOrHRAuditPage(
  body: API.QueryParkOrHRAuditPageInput,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRAuditListDtoPageOutput>('/api/ParkOrHR/GetParkOrHRAuditPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取园区信息 POST /api/ParkOrHR/GetParkOrHRForFront */
export async function getParkOrHRForFront(
  body: API.ParkHRForHomePageInput,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRDetailPageOutput>('/api/ParkOrHR/GetParkOrHRForFront', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的企业 GET /api/ParkOrHR/GetParkOrHRForMy */
export async function getParkOrHRForMy(options?: API.RequestConfig) {
  return request<API.ParkOrHRList>('/api/ParkOrHR/GetParkOrHRForMy', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取园区或人资企业详情 GET /api/ParkOrHR/GetParkOrHRInfo */
export async function getParkOrHRInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetParkOrHRInfoParams,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRInfo>('/api/ParkOrHR/GetParkOrHRInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据用户ID获取园区或人资企业详情 POST /api/ParkOrHR/GetParkOrHRInfoByUserId */
export async function getParkOrHRInfoByUserId(
  body: API.GetParkOrHRInfoByUserInput,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRInfo>('/api/ParkOrHR/GetParkOrHRInfoByUserId', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取园区的信息 POST /api/ParkOrHR/GetParkOrHRList */
export async function getParkOrHRList(body: API.ParkHRInput, options?: API.RequestConfig) {
  return request<API.ParkOrHRListPageOutput>('/api/ParkOrHR/GetParkOrHRList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取审核列表 POST /api/ParkOrHR/GetParkOrHRListForCheck */
export async function getParkOrHRListForCheck(body: API.ParkHRInput, options?: API.RequestConfig) {
  return request<API.ParkOrHRListPageOutput>('/api/ParkOrHR/GetParkOrHRListForCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取简单人资公司列表 POST /api/ParkOrHR/GetParkOrHRSimpleList */
export async function getParkOrHRSimpleList(
  body: API.QueryParkOrHRSimpleListInput,
  options?: API.RequestConfig
) {
  return request<API.ParkOrHRSimpleDto[]>('/api/ParkOrHR/GetParkOrHRSimpleList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/ParkOrHR/GetRandomNumber */
export async function getRandomNumber(options?: API.RequestConfig) {
  return request<string>('/api/ParkOrHR/GetRandomNumber', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/ParkOrHR/GetSerialNumber */
export async function getSerialNumber(options?: API.RequestConfig) {
  return request<string>('/api/ParkOrHR/GetSerialNumber', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 增加浏览记录 POST /api/ParkOrHR/ParkOrHRBrowse */
export async function parkOrHRBrowse(body: API.ProductViewInput, options?: API.RequestConfig) {
  return request<number>('/api/ParkOrHR/ParkOrHRBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更改状态 POST /api/ParkOrHR/SetStatus */
export async function setStatus(body: API.SetStatusInput, options?: API.RequestConfig) {
  return request<number>('/api/ParkOrHR/SetStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新广告信息 POST /api/ParkOrHR/UpdatParkOrHRAdvertise */
export async function updatParkOrHRAdvertise(
  body: API.UpdateProductAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkOrHR/UpdatParkOrHRAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户增加广告 POST /api/ParkOrHR/UserCreateParkOrHRAdvertise */
export async function userCreateParkOrHRAdvertise(
  body: API.UserCreateParkOrHRAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/ParkOrHR/UserCreateParkOrHRAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/ParkReward.ts

New file
@@ -0,0 +1,176 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增奖励申请跟踪 POST /api/ParkReward/AddParkRewardApplyFollow */
export async function addParkRewardApplyFollow(
  body: API.CreateParkRewardApplyFollowInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkReward/AddParkRewardApplyFollow', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增或修改政策福利 POST /api/ParkReward/CreateOrEditParkReward */
export async function createOrEditParkReward(
  body: API.CreateOrEditParkRewardInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkReward/CreateOrEditParkReward', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增或修改奖励申请 POST /api/ParkReward/CreateOrEditParkRewardApply */
export async function createOrEditParkRewardApply(
  body: API.CreateOrEditParkRewardApplyInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkReward/CreateOrEditParkRewardApply', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除奖励申请 GET /api/ParkReward/DeleteParkRewardApply */
export async function deleteParkRewardApply(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteParkRewardApplyParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkReward/DeleteParkRewardApply', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取最新奖励申请信息 GET /api/ParkReward/GetNewestParkRewardApplyInfo */
export async function getNewestParkRewardApplyInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetNewestParkRewardApplyInfoParams,
  options?: API.RequestConfig
) {
  return request<API.ParkRewardApplyFollowDto>('/api/ParkReward/GetNewestParkRewardApplyInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取奖励申请跟踪列表 POST /api/ParkReward/GetParkRewardApplyFollowList */
export async function getParkRewardApplyFollowList(
  body: API.GetParkRewardApplyFollowInput,
  options?: API.RequestConfig
) {
  return request<API.ParkRewardApplyFollowDtoPageOutput>(
    '/api/ParkReward/GetParkRewardApplyFollowList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取奖励申请详情 GET /api/ParkReward/GetParkRewardApplyInfoById */
export async function getParkRewardApplyInfoById(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetParkRewardApplyInfoByIdParams,
  options?: API.RequestConfig
) {
  return request<API.ParkRewardApplyInfoDto>('/api/ParkReward/GetParkRewardApplyInfoById', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取奖励申请列表 POST /api/ParkReward/GetParkRewardApplyList */
export async function getParkRewardApplyList(
  body: API.GetParkRewardApplyInput,
  options?: API.RequestConfig
) {
  return request<API.ParkRewardApplyDtoPageOutput>('/api/ParkReward/GetParkRewardApplyList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取政策福利明细详情 GET /api/ParkReward/GetParkRewardDetail */
export async function getParkRewardDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetParkRewardDetailParams,
  options?: API.RequestConfig
) {
  return request<API.ParkRewardOutPut>('/api/ParkReward/GetParkRewardDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取政策福利明细 POST /api/ParkReward/GetParkRewardList */
export async function getParkRewardList(body: API.GetParkRewardInput, options?: API.RequestConfig) {
  return request<API.ParkRewardOutPutPageOutput>('/api/ParkReward/GetParkRewardList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 前端获取政策福利列表 GET /api/ParkReward/GetParkRewardListForWeb */
export async function getParkRewardListForWeb(options?: API.RequestConfig) {
  return request<API.ParkRewardOutPut[]>('/api/ParkReward/GetParkRewardListForWeb', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 设置政策福利状态 POST /api/ParkReward/SetParkRewardStatus */
export async function setParkRewardStatus(
  body: API.SetParkRewardStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/ParkReward/SetParkRewardStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/PhonMessageHistory.ts

New file
@@ -0,0 +1,21 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取手机消息分页列表 POST /api/PhonMessageHistory/GetPhoneMessageHistoryPage */
export async function getPhoneMessageHistoryPage(
  body: API.QueryPhonMessageHistoryList,
  options?: API.RequestConfig
) {
  return request<API.PhonMessageHistoryListDtoPageOutput>(
    '/api/PhonMessageHistory/GetPhoneMessageHistoryPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/PingAn.ts

New file
@@ -0,0 +1,15 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取银行联行号查询 POST /api/PingAn/GetBankNo */
export async function getBankNo(body: API.QueryBankNoInput, options?: API.RequestConfig) {
  return request<API.BankNoQueryOutput>('/api/PingAn/GetBankNo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/PingAnBEDL.ts

New file
@@ -0,0 +1,240 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** BEDL_C00601
智能清分台账编码近期明细查询1_银企直联 POST /api/PingAnBEDL/InquiryIntoTheCurrentDetailsOfMainSubaccountAccountOne */
export async function inquiryIntoTheCurrentDetailsOfMainSubaccountAccountOne(
  body: API.PrimaryAcctDetialInputBase,
  options?: API.RequestConfig
) {
  return request<API.InquiryIntoTheCurrentDetailsOfMainSubaccountAccountOutput>(
    '/api/PingAnBEDL/InquiryIntoTheCurrentDetailsOfMainSubaccountAccountOne',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_C00602
智能清分台账编码近期明细查询2_银企直联 POST /api/PingAnBEDL/InquiryIntoTheCurrentDetailsOfMainSubaccountAccountTwo */
export async function inquiryIntoTheCurrentDetailsOfMainSubaccountAccountTwo(
  body: API.InquiryIntoTheCurrentDetailsOfMainSubaccountAccountTwoInput,
  options?: API.RequestConfig
) {
  return request<API.InquiryIntoTheCurrentDetailsOfMainSubaccountAccountOutput>(
    '/api/PingAnBEDL/InquiryIntoTheCurrentDetailsOfMainSubaccountAccountTwo',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_C014
智能清分账户转账笔数和限额维护和查询_银企直联 POST /api/PingAnBEDL/MaintainInquireSmartClearingAccount */
export async function maintainInquireSmartClearingAccount(
  body: API.MaintainInquireSmartClearingAccountInput,
  options?: API.RequestConfig
) {
  return request<API.MaintainInquireSmartClearingAccountOutput>(
    '/api/PingAnBEDL/MaintainInquireSmartClearingAccount',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_C011
转账对手白名单维护_银企直联 POST /api/PingAnBEDL/MaintainTransferCounterpartyWhiteList */
export async function maintainTransferCounterpartyWhiteList(
  body: API.MaintainTransferCounterpartyWhiteListInput,
  options?: API.RequestConfig
) {
  return request<API.MaintainTransferCounterpartyWhiteListOutput>(
    '/api/PingAnBEDL/MaintainTransferCounterpartyWhiteList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_C012
智能清分来账自动清分规则维护_银企直联 POST /api/PingAnBEDL/MaintainVosAcctAutomaticClearingRule */
export async function maintainVosAcctAutomaticClearingRule(
  body: API.MaintainVosAcctAutomaticClearingRuleInput,
  options?: API.RequestConfig
) {
  return request<API.MaintainVosAcctAutomaticClearingRuleOutput>(
    '/api/PingAnBEDL/MaintainVosAcctAutomaticClearingRule',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_C007
支付单状态查询_银企直联 POST /api/PingAnBEDL/PaymentOrderStatusQuery */
export async function paymentOrderStatusQuery(
  body: API.PaymentOrderStatusQueryInput,
  options?: API.RequestConfig
) {
  return request<API.PaymentOrderStatusQueryOutput>('/api/PingAnBEDL/PaymentOrderStatusQuery', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_C006
智能清分台帐编码近期明细查询_银企直联 POST /api/PingAnBEDL/PrimaryAcctDetialQuery */
export async function primaryAcctDetialQuery(
  body: API.PrimaryAcctDetialQueryInput,
  options?: API.RequestConfig
) {
  return request<API.PrimaryAcctDetialQueryOutput>('/api/PingAnBEDL/PrimaryAcctDetialQuery', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_C001
智能清分台账编码关系查询_银企直联 POST /api/PingAnBEDL/PrimaryAcctRelationshipQuery */
export async function primaryAcctRelationshipQuery(
  body: API.PrimaryAcctRelationshipQueryInput,
  options?: API.RequestConfig
) {
  return request<API.PrimaryAcctRelationshipQueryOutput>(
    '/api/PingAnBEDL/PrimaryAcctRelationshipQuery',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_C013
能清分来账自动清分规则查询_银企直联 POST /api/PingAnBEDL/QueryVosAcctAutomaticClearingRule */
export async function queryVosAcctAutomaticClearingRule(
  body: API.QueryVosAcctAutomaticClearingRuleInput,
  options?: API.RequestConfig
) {
  return request<API.QueryVosAcctAutomaticClearingRuleOutput>(
    '/api/PingAnBEDL/QueryVosAcctAutomaticClearingRule',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_C008
清分台账编码余额查询_银企直联 POST /api/PingAnBEDL/SubAccountBalanceQuery */
export async function subAccountBalanceQuery(
  body: API.SubAccountBalanceQueryInput,
  options?: API.RequestConfig
) {
  return request<API.SubAccountBalanceQueryOutput>('/api/PingAnBEDL/SubAccountBalanceQuery', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_C005
清分台账编码余额调整_银企直联 POST /api/PingAnBEDL/SubAcctBalanceAdjust */
export async function subAcctBalanceAdjust(
  body: API.SubAcctBalanceAdjustInput,
  options?: API.RequestConfig
) {
  return request<API.SubAcctBalanceAdjustOutput>('/api/PingAnBEDL/SubAcctBalanceAdjust', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_C002
清分台账编码维护和权限同步（AUDR）_银企直联 POST /api/PingAnBEDL/SubAcctMaintenance */
export async function subAcctMaintenance(
  body: API.SubAcctMaintenanceInput,
  options?: API.RequestConfig
) {
  return request<API.SubAcctMaintenanceOutput>('/api/PingAnBEDL/SubAcctMaintenance', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_C009
清分台账编码手工结息_银企直联 POST /api/PingAnBEDL/SubAcctSettlement */
export async function subAcctSettlement(
  body: API.SubAcctSettlementInput,
  options?: API.RequestConfig
) {
  return request<API.SubAcctSettlementOutput>('/api/PingAnBEDL/SubAcctSettlement', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/PingAnBEDL/Test */
export async function test(options?: API.RequestConfig) {
  return request<number>('/api/PingAnBEDL/Test', {
    method: 'GET',
    ...(options || {}),
  });
}

 src/services/api/PingAnELCP.ts

New file
@@ -0,0 +1,115 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** BEDL_EDZ001
对账数据查询_银企直联 POST /api/PingAnELCP/EDZ001 */
export async function eDZ001(body: API.EDZ001Input, options?: API.RequestConfig) {
  return request<API.EDZ001Output>('/api/PingAnELCP/EDZ001', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_EDZ002
对账结果反馈_银企直联 POST /api/PingAnELCP/EDZ002 */
export async function eDZ002(body: API.EDZ002Input, options?: API.RequestConfig) {
  return request<API.EDZ002Output>('/api/PingAnELCP/EDZ002', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_ELCP07
月结单查询（新）_银企直联 POST /api/PingAnELCP/MonthlyStatementQueryNew */
export async function monthlyStatementQueryNew(
  body: API.MonthlyStatementQueryNewInput,
  options?: API.RequestConfig
) {
  return request<API.MonthlyStatementQueryNewOutput>('/api/PingAnELCP/MonthlyStatementQueryNew', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_ELCP08
当日PDF回单文件查询接口（新）_银企直联 POST /api/PingAnELCP/QueryInterfaceOfPDFReturnSingleFileOnSameDayNew */
export async function queryInterfaceOfPDFReturnSingleFileOnSameDayNew(
  body: API.QueryInterfaceOfPDFReturnSingleFileOnSameDayNewInput,
  options?: API.RequestConfig
) {
  return request<API.QueryInterfaceOfPDFReturnSingleFileOnSameDayNewOutput>(
    '/api/PingAnELCP/QueryInterfaceOfPDFReturnSingleFileOnSameDayNew',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_ELC009
当日历史回单数据查询接口_银企直联 POST /api/PingAnELCP/SameDayHistoryReceiptDataQuery */
export async function sameDayHistoryReceiptDataQuery(
  body: API.SameDayHistoryReceiptDataQueryInput,
  options?: API.RequestConfig
) {
  return request<API.SameDayHistoryReceiptDataQueryOutput>(
    '/api/PingAnELCP/SameDayHistoryReceiptDataQuery',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_ELC001
回单数据查询_银企直联 POST /api/PingAnELCP/SingleDataQuery */
export async function singleDataQuery(body: API.SingleDataQueryInput, options?: API.RequestConfig) {
  return request<API.SingleDataQueryOutput>('/api/PingAnELCP/SingleDataQuery', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_ELCP10
单笔或多笔回单PDF合并下载（新）_银企直联 POST /api/PingAnELCP/SingleOrBatchReceiptPDFMergeDownloadNew */
export async function singleOrBatchReceiptPDFMergeDownloadNew(
  body: API.SingleOrBatchReceiptPDFMergeDownloadNewInput,
  options?: API.RequestConfig
) {
  return request<API.SingleOrBatchReceiptPDFMergeDownloadNewOutput>(
    '/api/PingAnELCP/SingleOrBatchReceiptPDFMergeDownloadNew',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/PingAnJGF.ts

New file
@@ -0,0 +1,130 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** BEDL_JGF007
监管批量代发查询_银企直联 POST /api/PingAnJGF/BatchInquiriesRegulators */
export async function batchInquiriesRegulators(
  body: API.BatchInquiriesRegulatorsInput,
  options?: API.RequestConfig
) {
  return request<API.BatchInquiriesRegulatorsOutput>('/api/PingAnJGF/BatchInquiriesRegulators', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_JGF006
监管批量代发_银企直联 POST /api/PingAnJGF/BatchIssuanceRegulators */
export async function batchIssuanceRegulators(
  body: API.BatchIssuanceRegulatorsInput,
  options?: API.RequestConfig
) {
  return request<API.BatchIssuanceRegulatorsOutput>('/api/PingAnJGF/BatchIssuanceRegulators', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** BEDL_JGF005
监管单笔代发查询_银企直联 POST /api/PingAnJGF/EnquiriesAboutSingleTransaction */
export async function enquiriesAboutSingleTransaction(
  body: API.EnquiriesAboutSingleTransactionInput,
  options?: API.RequestConfig
) {
  return request<API.EnquiriesAboutSingleTransactionOutput>(
    '/api/PingAnJGF/EnquiriesAboutSingleTransaction',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_JGF003
账户止付详情查询_银企直联 POST /api/PingAnJGF/InquiryAccountStopPaymentDetails */
export async function inquiryAccountStopPaymentDetails(
  body: API.InquiryAccountStopPaymentDetailsInput,
  options?: API.RequestConfig
) {
  return request<API.InquiryAccountStopPaymentDetailsOutput>(
    '/api/PingAnJGF/InquiryAccountStopPaymentDetails',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_JGF004
监管单笔代发_银企直联 POST /api/PingAnJGF/IssuanceSingleTransactionRegulators */
export async function issuanceSingleTransactionRegulators(
  body: API.IssuanceSingleTransactionRegulatorsInput,
  options?: API.RequestConfig
) {
  return request<API.IssuanceSingleTransactionRegulatorsOutput>(
    '/api/PingAnJGF/IssuanceSingleTransactionRegulators',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_JGF002
单笔监管止付支付申请_银企直联 POST /api/PingAnJGF/SingleApplicationSuspensionPayment */
export async function singleApplicationSuspensionPayment(
  body: API.SingleApplicationSuspensionPaymentInput,
  options?: API.RequestConfig
) {
  return request<API.SingleApplicationSuspensionPaymentOutput>(
    '/api/PingAnJGF/SingleApplicationSuspensionPayment',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** BEDL_JGF001
账户止付和解止付_银企直联 POST /api/PingAnJGF/StopPaymentAndSettlementAccounts */
export async function stopPaymentAndSettlementAccounts(
  body: API.StopPaymentAndSettlementAccountsInput,
  options?: API.RequestConfig
) {
  return request<API.StopPaymentAndSettlementAccountsOutput>(
    '/api/PingAnJGF/StopPaymentAndSettlementAccounts',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

 src/services/api/PlatUserAccountSetting.ts

New file
@@ -0,0 +1,84 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增或修改平台账号管理 POST /api/PlatUserAccountSetting/CreateOrEditPlatUserAccountSetting */
export async function createOrEditPlatUserAccountSetting(
  body: API.CreateOrEditPlatUserAccountSettingInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/PlatUserAccountSetting/CreateOrEditPlatUserAccountSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除平台账号 DELETE /api/PlatUserAccountSetting/DeletePlatUserAccountSetting */
export async function deletePlatUserAccountSetting(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeletePlatUserAccountSettingParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/PlatUserAccountSetting/DeletePlatUserAccountSetting', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取平台账号管理详情 GET /api/PlatUserAccountSetting/GetPlatUserAccountSettingInfo */
export async function getPlatUserAccountSettingInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPlatUserAccountSettingInfoParams,
  options?: API.RequestConfig
) {
  return request<API.PlatUserAccountSettingDto>(
    '/api/PlatUserAccountSetting/GetPlatUserAccountSettingInfo',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取平台账号管理列表 POST /api/PlatUserAccountSetting/GetPlatUserAccountSettingList */
export async function getPlatUserAccountSettingList(
  body: API.PageInput,
  options?: API.RequestConfig
) {
  return request<API.PlatUserAccountSettingDtoPageOutput>(
    '/api/PlatUserAccountSetting/GetPlatUserAccountSettingList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 设置平台账号管理状态 POST /api/PlatUserAccountSetting/SetPlatUserAccountSettingStatus */
export async function setPlatUserAccountSettingStatus(
  body: API.PlatUserAccountStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/PlatUserAccountSetting/SetPlatUserAccountSettingStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/PlatformServicePay.ts

New file
@@ -0,0 +1,168 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取平台服务支付二维码 POST /api/PlatformServicePay/GetPlaformServicePayQRCode */
export async function getPlaformServicePayQRCode(
  body: API.GetPlaformServicePayQRCodeInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/PlatformServicePay/GetPlaformServicePayQRCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取平台服务详情 POST /api/PlatformServicePay/GetPlatformServicePayDetail */
export async function getPlatformServicePayDetail(
  body: API.QueryPlatformServicePayDetailInput,
  options?: API.RequestConfig
) {
  return request<API.PlatformServicePayDetailDto>(
    '/api/PlatformServicePay/GetPlatformServicePayDetail',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取平台服务开票详情 POST /api/PlatformServicePay/GetPlatformServicePayInvoicingDetail */
export async function getPlatformServicePayInvoicingDetail(
  body: API.QueryPlatformServiceInvoicingDetailInput,
  options?: API.RequestConfig
) {
  return request<API.PlatformServicePayInvoicingDetailDto>(
    '/api/PlatformServicePay/GetPlatformServicePayInvoicingDetail',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取平台服务开票分页列表 POST /api/PlatformServicePay/GetPlatformServicePayInvoicingPage */
export async function getPlatformServicePayInvoicingPage(
  body: API.QueryPlatformServiceInvoicingListInput,
  options?: API.RequestConfig
) {
  return request<API.PlatformServicePayInvoicingListDtoPageOutput>(
    '/api/PlatformServicePay/GetPlatformServicePayInvoicingPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取平台服务分页列表 POST /api/PlatformServicePay/GetPlatformServicePayPage */
export async function getPlatformServicePayPage(
  body: API.QueryPlatformServicePayListInput,
  options?: API.RequestConfig
) {
  return request<API.PlatformServicePayListDtoPageOutput>(
    '/api/PlatformServicePay/GetPlatformServicePayPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取平台服务支付状态 GET /api/PlatformServicePay/GetPlatformServicePayStatus */
export async function getPlatformServicePayStatus(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPlatformServicePayStatusParams,
  options?: API.RequestConfig
) {
  return request<API.PayStatusEnum>('/api/PlatformServicePay/GetPlatformServicePayStatus', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 设置平台服务入账状态 POST /api/PlatformServicePay/SetPlatformServicePayCreditedStatus */
export async function setPlatformServicePayCreditedStatus(
  body: API.UpdatePlatformServicePayCreditedStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/PlatformServicePay/SetPlatformServicePayCreditedStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置平台服务开票状态 POST /api/PlatformServicePay/SetPlatformServicePayInvoicingStatus */
export async function setPlatformServicePayInvoicingStatus(
  body: API.UpdatePlatformServicePayInvoicingStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/PlatformServicePay/SetPlatformServicePayInvoicingStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/PlatformServicePay/TestGetPlatformServicePay */
export async function testGetPlatformServicePay(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItestGetPlatformServicePayParams,
  options?: API.RequestConfig
) {
  return request<API.PlatformServicePayDetailDto>(
    '/api/PlatformServicePay/TestGetPlatformServicePay',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 此处后端没有提供注释 GET /api/PlatformServicePay/TestPayNotify */
export async function testPayNotify(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItestPayNotifyParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/PlatformServicePay/TestPayNotify', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

 src/services/api/Product.ts

New file
@@ -0,0 +1,420 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 产品广告下架 GET /api/Product/AdvertiseOffShelf */
export async function advertiseOffShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertiseOffShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Product/AdvertiseOffShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品广告上架 GET /api/Product/AdvertiseOnShelf */
export async function advertiseOnShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertiseOnShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Product/AdvertiseOnShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品关注/取消关注 GET /api/Product/AttentOrNot */
export async function attentOrNot(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIattentOrNotParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Product/AttentOrNot', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 保存/发布产品 POST /api/Product/CreateProduct */
export async function createProduct(body: API.CreateProductInput, options?: API.RequestConfig) {
  return request<string>('/api/Product/CreateProduct', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品广告新增上架 POST /api/Product/CreateProductAdvertise */
export async function createProductAdvertise(
  body: API.CreateProductAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Product/CreateProductAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除产品 GET /api/Product/DeleteProduct */
export async function deleteProduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteProductParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Product/DeleteProduct', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 首页产品热销榜 POST /api/Product/GetHotProductAdvertise */
export async function getHotProductAdvertise(
  body: API.GetHotProductAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<API.HotProductAdvertiseInfo[]>('/api/Product/GetHotProductAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品服务--产品热销榜 POST /api/Product/GetHotProductAdvertiseByCategory */
export async function getHotProductAdvertiseByCategory(
  body: API.GetProductAdvertiseByCategoryInput,
  options?: API.RequestConfig
) {
  return request<API.HotProductAdvertiseInfoPageOutput>(
    '/api/Product/GetHotProductAdvertiseByCategory',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取产品广告位最后排序 GET /api/Product/GetMaxAdvertiseSequence */
export async function getMaxAdvertiseSequence(options?: API.RequestConfig) {
  return request<number>('/api/Product/GetMaxAdvertiseSequence', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 我的关注（产品） POST /api/Product/GetMyAttentions */
export async function getMyAttentions(
  body: API.GetMyProductAttentionsInput,
  options?: API.RequestConfig
) {
  return request<API.MyProductAttentionInfoPageOutput>('/api/Product/GetMyAttentions', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 我的产品 POST /api/Product/GetMyProducts */
export async function getMyProducts(body: API.GetMyProductsInput, options?: API.RequestConfig) {
  return request<API.MyProductInfoPageOutput>('/api/Product/GetMyProducts', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 最近发布产品 GET /api/Product/GetMyRecentProducts */
export async function getMyRecentProducts(options?: API.RequestConfig) {
  return request<API.MyRecentProductDto[]>('/api/Product/GetMyRecentProducts', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取产品详情 GET /api/Product/GetProduct */
export async function getProduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetProductParams,
  options?: API.RequestConfig
) {
  return request<API.ProductDetail>('/api/Product/GetProduct', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品广告详情 GET /api/Product/GetProductAdvertise */
export async function getProductAdvertise(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetProductAdvertiseParams,
  options?: API.RequestConfig
) {
  return request<API.ProductAdvertiseDetail>('/api/Product/GetProductAdvertise', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品服务--推荐产品 POST /api/Product/GetProductAdvertiseForRecommend */
export async function getProductAdvertiseForRecommend(
  body: API.GetHotProductAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<API.HotProductAdvertiseInfo[]>('/api/Product/GetProductAdvertiseForRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品广告列表 POST /api/Product/GetProductAdvertisesForManage */
export async function getProductAdvertisesForManage(
  body: API.GetProductAdvertisesForManageInput,
  options?: API.RequestConfig
) {
  return request<API.ProductAdvertiseForManagePageOutput>(
    '/api/Product/GetProductAdvertisesForManage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 产品详情 GET /api/Product/GetProductForDetail */
export async function getProductForDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetProductForDetailParams,
  options?: API.RequestConfig
) {
  return request<API.ProductDetailInfo>('/api/Product/GetProductForDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品服务--产品服务商 POST /api/Product/GetProductsByCategory */
export async function getProductsByCategory(
  body: API.GetProductByCategoryInput,
  options?: API.RequestConfig
) {
  return request<API.ProductDetailForHomePagePageOutput>('/api/Product/GetProductsByCategory', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 首页产品列表 POST /api/Product/GetProductsForHomePage */
export async function getProductsForHomePage(
  body: API.GetProductForHomePageInput,
  options?: API.RequestConfig
) {
  return request<API.ProductDetailForHomePagePageOutput>('/api/Product/GetProductsForHomePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品管理列表 POST /api/Product/GetProductsForManage */
export async function getProductsForManage(
  body: API.GetProductsForManageInput,
  options?: API.RequestConfig
) {
  return request<API.ProductForManagePageOutput>('/api/Product/GetProductsForManage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品审核列表 POST /api/Product/GetProductsWaitForCheck */
export async function getProductsWaitForCheck(
  body: API.GetProductsWaitForCheckInput,
  options?: API.RequestConfig
) {
  return request<API.ProductWaitForCheckPageOutput>('/api/Product/GetProductsWaitForCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 小程序---我的统计信息 GET /api/Product/GetUserAttentions */
export async function getUserAttentions(options?: API.RequestConfig) {
  return request<API.UserAttentionsDto>('/api/Product/GetUserAttentions', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 产品下架 GET /api/Product/OffShelf */
export async function offShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIoffShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Product/OffShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品上架 GET /api/Product/OnShelf */
export async function onShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIonShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Product/OnShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品浏览 POST /api/Product/ProductBrowse */
export async function productBrowse(body: API.ProductViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Product/ProductBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品审核 POST /api/Product/ProductCheck */
export async function productCheck(body: API.ProductCheckInput, options?: API.RequestConfig) {
  return request<number>('/api/Product/ProductCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品点赞 POST /api/Product/ProductThumbsUp */
export async function productThumbsUp(body: API.ProductThumbsUpInput, options?: API.RequestConfig) {
  return request<number>('/api/Product/ProductThumbsUp', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品编辑 POST /api/Product/UpdateProduct */
export async function updateProduct(body: API.UpdateProductInput, options?: API.RequestConfig) {
  return request<number>('/api/Product/UpdateProduct', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品广告编辑上架 POST /api/Product/UpdateProductAdvertise */
export async function updateProductAdvertise(
  body: API.UpdateProductAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Product/UpdateProductAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 用户产品广告投放 POST /api/Product/UserCreateProductAdvertise */
export async function userCreateProductAdvertise(
  body: API.UserCreateProductAdvertiseInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Product/UserCreateProductAdvertise', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Purchase.ts

New file
@@ -0,0 +1,191 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 评论审核 POST /api/Purchase/CommentCheck */
export async function commentCheck(body: API.CommentCheckInput, options?: API.RequestConfig) {
  return request<number>('/api/Purchase/CommentCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 退款处理 POST /api/Purchase/DealWithRefund */
export async function dealWithRefund(body: API.DealWithRefundInput, options?: API.RequestConfig) {
  return request<number>('/api/Purchase/DealWithRefund', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品购买信息删除 GET /api/Purchase/DeleteMyPurchase */
export async function deleteMyPurchase(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteMyPurchaseParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Purchase/DeleteMyPurchase', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 评论审核列表 POST /api/Purchase/GetCommentsForManage */
export async function getCommentsForManage(
  body: API.GetCommentsForManageInput,
  options?: API.RequestConfig
) {
  return request<API.CommentForManagePageOutput>('/api/Purchase/GetCommentsForManage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 详情页---商品评论 POST /api/Purchase/GetCommentsForProduct */
export async function getCommentsForProduct(
  body: API.GetCommentsForProductInput,
  options?: API.RequestConfig
) {
  return request<API.CommentForProductPageOutput>('/api/Purchase/GetCommentsForProduct', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 我的买入 POST /api/Purchase/GetMyPurchases */
export async function getMyPurchases(body: API.GetMyPurchasesInput, options?: API.RequestConfig) {
  return request<API.MyPurchaseDtoPageOutput>('/api/Purchase/GetMyPurchases', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 最近购买产品 GET /api/Purchase/GetMyRecentPurchases */
export async function getMyRecentPurchases(options?: API.RequestConfig) {
  return request<API.MyRecentPurchaseDto[]>('/api/Purchase/GetMyRecentPurchases', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 我的卖出 POST /api/Purchase/GetMySells */
export async function getMySells(body: API.GetMySellsInput, options?: API.RequestConfig) {
  return request<API.MySellDtoPageOutput>('/api/Purchase/GetMySells', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 平台交易列表 POST /api/Purchase/GetPlatFormPurchases */
export async function getPlatFormPurchases(
  body: API.GetPlatFormPurchasesInput,
  options?: API.RequestConfig
) {
  return request<API.PlatFormPurchasePageOutput>('/api/Purchase/GetPlatFormPurchases', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 买入产品确认验收 GET /api/Purchase/MyPurchaseCheck */
export async function myPurchaseCheck(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APImyPurchaseCheckParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Purchase/MyPurchaseCheck', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 购买产品评论 POST /api/Purchase/PurchasedProductComment */
export async function purchasedProductComment(
  body: API.PurchasedProductCommentInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Purchase/PurchasedProductComment', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品评论---点赞 POST /api/Purchase/PurchasedProductCommentThumbsUp */
export async function purchasedProductCommentThumbsUp(
  body: API.PurchasedProductCommentThumbsUpInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Purchase/PurchasedProductCommentThumbsUp', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 购买 POST /api/Purchase/PurchaseProduct */
export async function purchaseProduct(
  body: API.CreatePurchasedProductInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Purchase/PurchaseProduct', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 退款申请 POST /api/Purchase/RefundApply */
export async function refundApply(body: API.RefundApplyInput, options?: API.RequestConfig) {
  return request<number>('/api/Purchase/RefundApply', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Recharge.ts

New file
@@ -0,0 +1,87 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 客户线下充值 POST /api/Recharge/CreateOfflineRecharge */
export async function createOfflineRecharge(
  body: API.CreateRechargeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Recharge/CreateOfflineRecharge', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 账号余额--获取客户的充值记录 POST /api/Recharge/GetCustomerAmountList */
export async function getCustomerAmountList(
  body: API.CusmterAmountListInput,
  options?: API.RequestConfig
) {
  return request<API.CusmterAmountDtoPageOutput>('/api/Recharge/GetCustomerAmountList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 账户余额--充值记录 获取某个客户的充值记录 POST /api/Recharge/GetCustomerRechargeList */
export async function getCustomerRechargeList(
  body: API.CustomerRechargeListInput,
  options?: API.RequestConfig
) {
  return request<API.RechargeDtoPageOutput>('/api/Recharge/GetCustomerRechargeList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 账户余额--接受打赏  某个客户的打赏记录 POST /api/Recharge/GetCustomerRewardList */
export async function getCustomerRewardList(
  body: API.CustomerRechargeListInput,
  options?: API.RequestConfig
) {
  return request<API.CusmterRewardDtoPageOutput>('/api/Recharge/GetCustomerRewardList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 客户充值 POST /api/Recharge/GetRechargeList */
export async function getRechargeList(body: API.RechargeListInput, options?: API.RequestConfig) {
  return request<API.RechargeDtoPageOutput>('/api/Recharge/GetRechargeList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 平台打赏 POST /api/Recharge/GetRewardList */
export async function getRewardList(body: API.CusmterRewardListInput, options?: API.RequestConfig) {
  return request<API.CusmterRewardDtoPageOutput>('/api/Recharge/GetRewardList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Resource.ts

New file
@@ -0,0 +1,251 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

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

/** 资源审核 POST /api/Resource/CheckResource */
export async function checkResource(
  body: API.CreateOrEditResourceInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Resource/CheckResource', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增修改资源 POST /api/Resource/CreateOrEditResource */
export async function createOrEditResource(
  body: API.CreateOrEditResourceInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Resource/CreateOrEditResource', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除资源 GET /api/Resource/DeleteResource */
export async function deleteResource(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteResourceParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Resource/DeleteResource', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取前端资源显示详情 GET /api/Resource/GetFrontResourceInfo */
export async function getFrontResourceInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFrontResourceInfoParams,
  options?: API.RequestConfig
) {
  return request<API.ResourceFrontInfoDto>('/api/Resource/GetFrontResourceInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据用户ID获取前端资源显示详情 GET /api/Resource/GetFrontResourceInfoByUserId */
export async function getFrontResourceInfoByUserId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFrontResourceInfoByUserIdParams,
  options?: API.RequestConfig
) {
  return request<API.ResourceFrontInfoDto>('/api/Resource/GetFrontResourceInfoByUserId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取前端资源显示列表 POST /api/Resource/GetFrontResourceList */
export async function getFrontResourceList(
  body: API.GetFrontResourceListInput,
  options?: API.RequestConfig
) {
  return request<API.GetFrontResourceListPageOutput>('/api/Resource/GetFrontResourceList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的资源列表 POST /api/Resource/GetMyResourceList */
export async function getMyResourceList(
  body: API.GetMyResourceListInput,
  options?: API.RequestConfig
) {
  return request<API.GetFrontResourceListPageOutput>('/api/Resource/GetMyResourceList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取资源详情 GET /api/Resource/GetResourceInfo */
export async function getResourceInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetResourceInfoParams,
  options?: API.RequestConfig
) {
  return request<API.ResourceInfoDto>('/api/Resource/GetResourceInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取资源列表 POST /api/Resource/GetResourceList */
export async function getResourceList(body: API.ResourceListInput, options?: API.RequestConfig) {
  return request<API.ResourceListDtoPageOutput>('/api/Resource/GetResourceList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取审核资源列表 POST /api/Resource/GetResourceListForCheck */
export async function getResourceListForCheck(
  body: API.ResourceListInput,
  options?: API.RequestConfig
) {
  return request<API.ResourceListDtoPageOutput>('/api/Resource/GetResourceListForCheck', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取资源推荐列表 GET /api/Resource/GetResourceListForRecommend */
export async function getResourceListForRecommend(options?: API.RequestConfig) {
  return request<API.ResourceListDto[]>('/api/Resource/GetResourceListForRecommend', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 根据用户获取user的资源订单 POST /api/Resource/GetUserResourceList */
export async function getUserResourceList(
  body: API.UserOrderListInput,
  options?: API.RequestConfig
) {
  return request<API.GetFrontResourceListPageOutput>('/api/Resource/GetUserResourceList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资源浏览 POST /api/Resource/ResourceAttention */
export async function resourceAttention(body: API.ResourceViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Resource/ResourceAttention', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资源浏览 POST /api/Resource/ResourceBrowse */
export async function resourceBrowse(body: API.ResourceViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Resource/ResourceBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置资源推荐 POST /api/Resource/SetResourceRecommend */
export async function setResourceRecommend(
  body: API.ResourceRecommendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Resource/SetResourceRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置资源状态 POST /api/Resource/SetResourceStatus */
export async function setResourceStatus(body: API.OrderStatusInput, options?: API.RequestConfig) {
  return request<number>('/api/Resource/SetResourceStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置资源类型 GET /api/Resource/SetResourceType */
export async function setResourceType(body: API.ResourceDelistReason, options?: API.RequestConfig) {
  return request<number>('/api/Resource/SetResourceType', {
    method: 'GET',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/SearchSetting.ts

New file
@@ -0,0 +1,101 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 搜索管理--新建编辑 POST /api/SearchSetting/CreateOrEditSearchSetting */
export async function createOrEditSearchSetting(
  body: API.CreateOrEditSearchInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/SearchSetting/CreateOrEditSearchSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 搜索管理--禁用启用 POST /api/SearchSetting/EnableSearchSetting */
export async function enableSearchSetting(
  body: API.EnableSearchSettingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/SearchSetting/EnableSearchSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 根据获得全部指定类型搜索条件 POST /api/SearchSetting/GetAllSearchSettingList */
export async function getAllSearchSettingList(
  body: API.GetSearchSettingListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSearchSettingList[]>('/api/SearchSetting/GetAllSearchSettingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取查询条件列表 GET /api/SearchSetting/GetSearchConditionList */
export async function getSearchConditionList(options?: API.RequestConfig) {
  return request<API.SearchConditionList[]>('/api/SearchSetting/GetSearchConditionList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 搜索管理--列表 POST /api/SearchSetting/GetSearchSettingList */
export async function getSearchSettingList(
  body: API.GetSearchSettingListInput,
  options?: API.RequestConfig
) {
  return request<API.GetSearchSettingListPageOutput>('/api/SearchSetting/GetSearchSettingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 根据类型获得指定类型搜索条件 POST /api/SearchSetting/GetTypeSearchSettingList */
export async function getTypeSearchSettingList(
  body: API.GetTypeSearchSettingListInput,
  options?: API.RequestConfig
) {
  return request<API.GetTypeSearchSettingList[]>('/api/SearchSetting/GetTypeSearchSettingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 修改推荐状态 POST /api/SearchSetting/SetRecommendSearchSetting */
export async function setRecommendSearchSetting(
  body: API.SetRecommendSearchSettingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/SearchSetting/SetRecommendSearchSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Setting.ts

New file
@@ -0,0 +1,434 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 广告价位下架 GET /api/Setting/AdvertisePriceOffShelf */
export async function advertisePriceOffShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertisePriceOffShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Setting/AdvertisePriceOffShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 广告价位上架 GET /api/Setting/AdvertisePriceOnShelf */
export async function advertisePriceOnShelf(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIadvertisePriceOnShelfParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Setting/AdvertisePriceOnShelf', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 新建系统配置 POST /api/Setting/CreateInsureSetting */
export async function createInsureSetting(
  body: API.CreateInsureSettingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Setting/CreateInsureSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建或修改平台对外联系电话 POST /api/Setting/CreateOrEditPlatformContact */
export async function createOrEditPlatformContact(
  body: API.CreateOrEditPlatformContactInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Setting/CreateOrEditPlatformContact', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增/编辑广告价位 POST /api/Setting/CreateOrUpdateAdvertisePrice */
export async function createOrUpdateAdvertisePrice(
  body: API.CreateOrUpdateAdvertisePriceInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Setting/CreateOrUpdateAdvertisePrice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 添加/编辑类别 POST /api/Setting/CreateOrUpdateCategory */
export async function createOrUpdateCategory(
  body: API.CreateOrUpdateCategoryInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Setting/CreateOrUpdateCategory', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增/编辑资讯打赏分成 POST /api/Setting/CreateOrUpdateRewardPercentage */
export async function createOrUpdateRewardPercentage(
  body: API.CreateOrUpdateRewardPercentageInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Setting/CreateOrUpdateRewardPercentage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 产品、资讯、自定义、快捷评论标签添加/编辑 POST /api/Setting/CreateOrUpdateTag */
export async function createOrUpdateTag(
  body: API.CreateOrUpdateTagInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Setting/CreateOrUpdateTag', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 广告价位删除 GET /api/Setting/DeleteAdvertisePrice */
export async function deleteAdvertisePrice(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteAdvertisePriceParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Setting/DeleteAdvertisePrice', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取广告位单价 GET /api/Setting/GetAdvertisePrice */
export async function getAdvertisePrice(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetAdvertisePriceParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Setting/GetAdvertisePrice', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 广告价位列表 POST /api/Setting/GetAdvertisePriceInfos */
export async function getAdvertisePriceInfos(
  body: API.GetAdvertisePriceInfosInput,
  options?: API.RequestConfig
) {
  return request<API.AdvertisePriceInfo[]>('/api/Setting/GetAdvertisePriceInfos', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/Setting/GetAllCategories */
export async function getAllCategories(options?: API.RequestConfig) {
  return request<API.CategoryAllDto[]>('/api/Setting/GetAllCategories', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 根据业务类型获取相关配置 GET /api/Setting/GetBusinessSettingByType */
export async function getBusinessSettingByType(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetBusinessSettingByTypeParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Setting/GetBusinessSettingByType', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品资讯类别列表 POST /api/Setting/GetCategories */
export async function getCategories(body: API.GetCategoriesInput, options?: API.RequestConfig) {
  return request<API.CategoryDto[]>('/api/Setting/GetCategories', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取类别详情 GET /api/Setting/GetCategory */
export async function getCategory(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCategoryParams,
  options?: API.RequestConfig
) {
  return request<API.CategoryInfo>('/api/Setting/GetCategory', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 根据catetoryType获取Menu  行业服务 = 0 行业配套 = 1  甲方需求 = 2 行业资讯 = 3; GET /api/Setting/GetCategoryMenu */
export async function getCategoryMenu(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetCategoryMenuParams,
  options?: API.RequestConfig
) {
  return request<API.CategoryMenu[]>('/api/Setting/GetCategoryMenu', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 资讯类别目录 GET /api/Setting/GetInformationCategoryMenu */
export async function getInformationCategoryMenu(options?: API.RequestConfig) {
  return request<API.CategoryMenu[]>('/api/Setting/GetInformationCategoryMenu', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取初始配置 GET /api/Setting/GetInitSettings */
export async function getInitSettings(options?: API.RequestConfig) {
  return request<API.InitSettingInfo>('/api/Setting/GetInitSettings', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取价格配置列表 POST /api/Setting/GetInsureSettingPrices */
export async function getInsureSettingPrices(
  body: API.GetInsureSettingPricesInput,
  options?: API.RequestConfig
) {
  return request<API.InsureSettingPriceDto[]>('/api/Setting/GetInsureSettingPrices', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取配置列表 POST /api/Setting/GetInsureSettings */
export async function getInsureSettings(
  body: API.GetInsureSettingsInput,
  options?: API.RequestConfig
) {
  return request<API.InsureSettingDto[]>('/api/Setting/GetInsureSettings', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取配置tab POST /api/Setting/GetInsureSubSettings */
export async function getInsureSubSettings(
  body: API.GetInsureSubSettingsInput,
  options?: API.RequestConfig
) {
  return request<API.InsureSubSetting[]>('/api/Setting/GetInsureSubSettings', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 行业服务类别：园区 人资公司 订单 GET /api/Setting/GetParkOrHRCategoryMenu */
export async function getParkOrHRCategoryMenu(options?: API.RequestConfig) {
  return request<API.CategoryMenu[]>('/api/Setting/GetParkOrHRCategoryMenu', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 根据catagory id 获取联系方式 GET /api/Setting/GetPlatformContactByCategoryId */
export async function getPlatformContactByCategoryId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetPlatformContactByCategoryIdParams,
  options?: API.RequestConfig
) {
  return request<API.PlatformContactList>('/api/Setting/GetPlatformContactByCategoryId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取平台的联系方式列表 GET /api/Setting/GetPlatformContactList */
export async function getPlatformContactList(options?: API.RequestConfig) {
  return request<API.PlatformContactList[]>('/api/Setting/GetPlatformContactList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 行业配套类别目录 GET /api/Setting/GetProductCategoryMenu */
export async function getProductCategoryMenu(options?: API.RequestConfig) {
  return request<API.CategoryMenu[]>('/api/Setting/GetProductCategoryMenu', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 甲方资源 GET /api/Setting/GetResourceCategoryMenu */
export async function getResourceCategoryMenu(options?: API.RequestConfig) {
  return request<API.CategoryMenu[]>('/api/Setting/GetResourceCategoryMenu', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 资讯打赏分成列表 POST /api/Setting/GetRewardPercentages */
export async function getRewardPercentages(
  body: API.GetRewardPercentagesInput,
  options?: API.RequestConfig
) {
  return request<API.RewardPercentageInfo[]>('/api/Setting/GetRewardPercentages', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 标签目录 GET /api/Setting/GetTagMenu */
export async function getTagMenu(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetTagMenuParams,
  options?: API.RequestConfig
) {
  return request<API.TagMenu[]>('/api/Setting/GetTagMenu', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 产品、资讯、快捷评论标签列表 POST /api/Setting/GetTags */
export async function getTags(body: API.GetTagsInput, options?: API.RequestConfig) {
  return request<API.TagDto[]>('/api/Setting/GetTags', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 显示/隐藏类别 POST /api/Setting/SetCategoryVis */
export async function setCategoryVis(body: API.SetCategoryVisInput, options?: API.RequestConfig) {
  return request<number>('/api/Setting/SetCategoryVis', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 配置价格设置 POST /api/Setting/SetInsureSettingPrice */
export async function setInsureSettingPrice(
  body: API.SetInsureSettingPriceInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Setting/SetInsureSettingPrice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 显示/隐藏标签 POST /api/Setting/SetTagVis */
export async function setTagVis(body: API.SetTagVisInput, options?: API.RequestConfig) {
  return request<number>('/api/Setting/SetTagVis', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新系统配置 POST /api/Setting/UpdateInsureSetting */
export async function updateInsureSetting(body: API.InsureSettingDto, options?: API.RequestConfig) {
  return request<number>('/api/Setting/UpdateInsureSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Statistics.ts

New file
@@ -0,0 +1,33 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 客户端首页头部统计 GET /api/Statistics/GetHeadSumInfo */
export async function getHeadSumInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetHeadSumInfoParams,
  options?: API.RequestConfig
) {
  return request<API.GetHeadSumInfo>('/api/Statistics/GetHeadSumInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 客户端首页柱状图 POST /api/Statistics/GetInsureInfoByMonth */
export async function getInsureInfoByMonth(
  body: API.GetInsureInfoByMonthInput,
  options?: API.RequestConfig
) {
  return request<API.GetInsureInfoByMonth[]>('/api/Statistics/GetInsureInfoByMonth', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/SysOrg.ts

New file
@@ -0,0 +1,104 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增组织 POST /api/SysOrg/AddSysOrg */
export async function addSysOrg(body: API.AddSysOrgInput, options?: API.RequestConfig) {
  return request<number>('/api/SysOrg/AddSysOrg', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取所有部门下拉列表 GET /api/SysOrg/GetAllDepartmentDropDownList */
export async function getAllDepartmentDropDownList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetAllDepartmentDropDownListParams,
  options?: API.RequestConfig
) {
  return request<API.SysOrgDropDownListOutput[]>('/api/SysOrg/GetAllDepartmentDropDownList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取组织明细详情 POST /api/SysOrg/GetSysOrgDetail */
export async function getSysOrgDetail(
  body: API.QuerySysOrgDetailInput,
  options?: API.RequestConfig
) {
  return request<API.SysOrgDetailOutput>('/api/SysOrg/GetSysOrgDetail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取组织下拉列表 GET /api/SysOrg/GetSysOrgDropDownList */
export async function getSysOrgDropDownList(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetSysOrgDropDownListParams,
  options?: API.RequestConfig
) {
  return request<API.SysOrgDropDownListOutput[]>('/api/SysOrg/GetSysOrgDropDownList', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取组织架构树列表 GET /api/SysOrg/GetSysOrgLevelList */
export async function getSysOrgLevelList(options?: API.RequestConfig) {
  return request<API.SysOrgLevelOutput[]>('/api/SysOrg/GetSysOrgLevelList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取组织分页列表 POST /api/SysOrg/GetSysOrgPage */
export async function getSysOrgPage(body: API.QuerySysOrgListInput, options?: API.RequestConfig) {
  return request<API.SysOrgListOutputPageOutput>('/api/SysOrg/GetSysOrgPage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置组织状态 POST /api/SysOrg/SetSysOrgStatus */
export async function setSysOrgStatus(body: API.SetSysOrgStatusInput, options?: API.RequestConfig) {
  return request<number>('/api/SysOrg/SetSysOrgStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新组织 POST /api/SysOrg/UpdateSysOrg */
export async function updateSysOrg(body: API.UpdateSysOrgInput, options?: API.RequestConfig) {
  return request<number>('/api/SysOrg/UpdateSysOrg', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/SystemNotice.ts

New file
@@ -0,0 +1,117 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增系统公告 POST /api/SystemNotice/AddNotice */
export async function addNotice(body: API.AddNoticeInput, options?: API.RequestConfig) {
  return request<number>('/api/SystemNotice/AddNotice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除系统公告 POST /api/SystemNotice/FakeDeleteNotice */
export async function fakeDeleteNotice(body: API.BaseIdInput, options?: API.RequestConfig) {
  return request<number>('/api/SystemNotice/FakeDeleteNotice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取系统公告详情 POST /api/SystemNotice/GetSystemNoticeDetail */
export async function getSystemNoticeDetail(
  body: API.QuerySystemNoticeDetailInput,
  options?: API.RequestConfig
) {
  return request<API.SystemNoticeDetailDto>('/api/SystemNotice/GetSystemNoticeDetail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取系统公告分页列表 POST /api/SystemNotice/GetSystemNoticePage */
export async function getSystemNoticePage(
  body: API.QuerySystemNoticeListInput,
  options?: API.RequestConfig
) {
  return request<API.SystemNoticeListDtoPageOutput>('/api/SystemNotice/GetSystemNoticePage', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取系统公告展示 POST /api/SystemNotice/GetSystemNoticeShow */
export async function getSystemNoticeShow(body: API.PageInput, options?: API.RequestConfig) {
  return request<API.SystemNoticeShowDtoPageOutput>('/api/SystemNotice/GetSystemNoticeShow', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 下架公告 POST /api/SystemNotice/OffShelfNotice */
export async function offShelfNotice(body: API.BaseIdInput, options?: API.RequestConfig) {
  return request<number>('/api/SystemNotice/OffShelfNotice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上架公告 POST /api/SystemNotice/OnShelfNotice */
export async function onShelfNotice(body: API.BaseIdInput, options?: API.RequestConfig) {
  return request<number>('/api/SystemNotice/OnShelfNotice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置公告状态 POST /api/SystemNotice/SetNoticeStatus */
export async function setNoticeStatus(body: API.SetNoticeStatusInput, options?: API.RequestConfig) {
  return request<number>('/api/SystemNotice/SetNoticeStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 更新系统公告 POST /api/SystemNotice/UpdateNotice */
export async function updateNotice(body: API.UpdateNoticeInput, options?: API.RequestConfig) {
  return request<number>('/api/SystemNotice/UpdateNotice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/TencentUser.ts

New file
@@ -0,0 +1,132 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 用户咨询信息记录 POST /api/TencentUser/AddTencentConsult */
export async function addTencentConsult(body: API.TencentConsultDto, options?: API.RequestConfig) {
  return request<number>('/api/TencentUser/AddTencentConsult', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增腾讯用户 POST /api/TencentUser/AddTencentUser */
export async function addTencentUser(body: API.TencentUserInput, options?: API.RequestConfig) {
  return request<API.TencentUserOutput>('/api/TencentUser/AddTencentUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除腾讯IM账号对应关系 DELETE /api/TencentUser/DeleteTencentUser */
export async function deleteTencentUser(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteTencentUserParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/TencentUser/DeleteTencentUser', {
    method: 'DELETE',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取腾讯签名 GET /api/TencentUser/GenTencentSig */
export async function genTencentSig(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgenTencentSigParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/TencentUser/GenTencentSig', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取客服人员的user Id GET /api/TencentUser/GetServeUser */
export async function getServeUser(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetServeUserParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/TencentUser/GetServeUser', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/TencentUser/GetTencentUserByUserId */
export async function getTencentUserByUserId(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetTencentUserByUserIdParams,
  options?: API.RequestConfig
) {
  return request<API.TencentUserDto>('/api/TencentUser/GetTencentUserByUserId', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取腾讯IM账号对应关系 POST /api/TencentUser/GetTencentUserList */
export async function getTencentUserList(
  body: API.GetTencentUserInput,
  options?: API.RequestConfig
) {
  return request<API.TencentUserDtoPageOutput>('/api/TencentUser/GetTencentUserList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置腾讯IM账号对应关系 POST /api/TencentUser/SetUserTencentUserId */
export async function setUserTencentUserId(
  body: API.SetUserTencentUserIdDto,
  options?: API.RequestConfig
) {
  return request<number>('/api/TencentUser/SetUserTencentUserId', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 禁用腾讯IM账号对应关系 GET /api/TencentUser/TencentUserEnableOrForbid */
export async function tencentUserEnableOrForbid(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItencentUserEnableOrForbidParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/TencentUser/TencentUserEnableOrForbid', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

 src/services/api/Test.ts

New file
@@ -0,0 +1,175 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 添加系统 模板数据参数字典 POST /api/Test/AddSystemTemplateDataParamSetting */
export async function addSystemTemplateDataParamSetting(
  body: API.AddSystemTemplateDataParamSettingInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Test/AddSystemTemplateDataParamSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 指定签约用户，发起签约，获取签约密钥，拉起签约页面 POST /api/Test/DataprepareCreate */
export async function dataprepareCreate(options?: API.RequestConfig) {
  return request<API.DataprepareCreateOutput>('/api/Test/DataprepareCreate', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 文件上传接口，支持pdf、doc、docx类型的合同模板文件 POST /api/Test/FileUpload */
export async function fileUpload(body: {}, file?: File, options?: API.RequestConfig) {
  const formData = new FormData();

  if (file) {
    formData.append('file', file);
  }

  Object.keys(body).forEach((ele) => {
    const item = (body as any)[ele];

    if (item !== undefined && item !== null) {
      formData.append(
        ele,
        typeof item === 'object' && !(item instanceof File) ? JSON.stringify(item) : item
      );
    }
  });

  return request<API.FileUploadOutput>('/api/Test/FileUpload', {
    method: 'POST',
    data: formData,
    requestType: 'form',
    ...(options || {}),
  });
}

/** 根据印章ID或者印章名称分页查询当前用户的印章列表。印章ID是精确查询，印章名称是模糊查询。 POST /api/Test/SealBatchQuery */
export async function sealBatchQuery(body: API.SealBatchQueryInput, options?: API.RequestConfig) {
  return request<API.SealBatchQueryOutput>('/api/Test/SealBatchQuery', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 添加企业印章，用于后续企业认证并在PDF合同上添加电子签章 POST /api/Test/SealSave */
export async function sealSave(body: API.SealSaveInput, options?: API.RequestConfig) {
  return request<API.SealSaveOutput>('/api/Test/SealSave', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询签约结果，获取签约完成的文件 POST /api/Test/SignorderQuery */
export async function signorderQuery(options?: API.RequestConfig) {
  return request<API.SignorderQueryOutput>('/api/Test/SignorderQuery', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 根据参数查询合同模板列表，主要返回合同模板摘要信息 POST /api/Test/TemplateBatchQuery */
export async function templateBatchQuery(
  body: API.TemplateBatchQueryInput,
  options?: API.RequestConfig
) {
  return request<API.TemplateBatchQueryOutput>('/api/Test/TemplateBatchQuery', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建合同模板，向PDF模板文件中添加填写控件，以便后续通过这些控件来填充内容。 POST /api/Test/TemplateSave */
export async function templateSave(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItemplateSaveParams,
  options?: API.RequestConfig
) {
  return request<API.TemplateSaveOutput>('/api/Test/TemplateSave', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/Test/TestEventBusSendPhoneMessge */
export async function testEventBusSendPhoneMessge(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItestEventBusSendPhoneMessgeParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Test/TestEventBusSendPhoneMessge', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/Test/TestQRCodePay */
export async function testQRCodePay(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItestQRCodePayParams,
  options?: API.RequestConfig
) {
  return request<string>('/api/Test/TestQRCodePay', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/Test/TestRetturnResult */
export async function testRetturnResult(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItestRetturnResultParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Test/TestRetturnResult', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /api/Test/TestSendPhoneMessge */
export async function testSendPhoneMessge(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItestSendPhoneMessgeParams,
  options?: API.RequestConfig
) {
  return request<any>('/api/Test/TestSendPhoneMessge', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

 src/services/api/ThirdPartCallBack.ts

New file
@@ -0,0 +1,34 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 异步回调通知 POST /api/ThirdPartCallBack/BestSignCallBackNotice */
export async function bestSignCallBackNotice(
  body: API.SignCallBackNoticeEto,
  options?: API.RequestConfig
) {
  return request<any>('/api/ThirdPartCallBack/BestSignCallBackNotice', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 单笔转账到支付宝账户、单笔转账到银行卡、C2C现金红包、B2C现金红包单据状态变更后触发的通知 POST /api/ThirdPartCallBack/NotifyOrderChanged */
export async function notifyOrderChanged(options?: API.RequestConfig) {
  return request<any>('/api/ThirdPartCallBack/NotifyOrderChanged', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 信任签异步通知 POST /api/ThirdPartCallBack/SignorderNotify */
export async function signorderNotify(options?: API.RequestConfig) {
  return request<any>('/api/ThirdPartCallBack/SignorderNotify', {
    method: 'POST',
    ...(options || {}),
  });
}

 src/services/api/Training.ts

New file
@@ -0,0 +1,179 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

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

/** 创建编辑培训 POST /api/Training/CreateOrEditTraining */
export async function createOrEditTraining(
  body: API.CreateOrEditTrainingInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/Training/CreateOrEditTraining', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除培训 GET /api/Training/DeleteTraining */
export async function deleteTraining(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteTrainingParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Training/DeleteTraining', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取前端培训详情 GET /api/Training/GetFronTrainingInfo */
export async function getFronTrainingInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetFronTrainingInfoParams,
  options?: API.RequestConfig
) {
  return request<API.TrainingDto>('/api/Training/GetFronTrainingInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取前端培训列表 POST /api/Training/GetFrontTrainingList */
export async function getFrontTrainingList(
  body: API.GetFrontTrainingListInput,
  options?: API.RequestConfig
) {
  return request<API.TrainingDtoPageOutput>('/api/Training/GetFrontTrainingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取我的培训列表 POST /api/Training/GetMyTrainingList */
export async function getMyTrainingList(
  body: API.GetMyTrainingListInput,
  options?: API.RequestConfig
) {
  return request<API.TrainingDtoPageOutput>('/api/Training/GetMyTrainingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取后端培训详情 GET /api/Training/GetTrainingInfo */
export async function getTrainingInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetTrainingInfoParams,
  options?: API.RequestConfig
) {
  return request<API.TrainingDto>('/api/Training/GetTrainingInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取后端培训列表 POST /api/Training/GetTrainingList */
export async function getTrainingList(body: API.TrainingListInput, options?: API.RequestConfig) {
  return request<API.TrainingDtoPageOutput>('/api/Training/GetTrainingList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取推荐培训信息 GET /api/Training/GetTrainingRecommend */
export async function getTrainingRecommend(options?: API.RequestConfig) {
  return request<API.TrainingDto[]>('/api/Training/GetTrainingRecommend', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 设置培训推荐 POST /api/Training/SetTrainingRecommend */
export async function setTrainingRecommend(
  body: API.TrainingRecommendInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Training/SetTrainingRecommend', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置培训状态 POST /api/Training/SetTrainingStatus */
export async function setTrainingStatus(body: API.OrderStatusInput, options?: API.RequestConfig) {
  return request<number>('/api/Training/SetTrainingStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 培训收藏浏览 POST /api/Training/TrainingAttention */
export async function trainingAttention(body: API.TrainingViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Training/TrainingAttention', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 培训记录浏览 POST /api/Training/TrainingBrowse */
export async function trainingBrowse(body: API.TrainingViewInput, options?: API.RequestConfig) {
  return request<number>('/api/Training/TrainingBrowse', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 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 || {}),
  });
}

 src/services/api/UserRole.ts

New file
@@ -0,0 +1,129 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 新增后台管理账户 POST /api/UserRole/CreateBackClientUser */
export async function createBackClientUser(
  body: API.CreateBackClientUserInput,
  options?: API.RequestConfig
) {
  return request<string>('/api/UserRole/CreateBackClientUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 新增角色 POST /api/UserRole/CreateRole */
export async function createRole(body: API.CreateBaseRoleInput, options?: API.RequestConfig) {
  return request<string>('/api/UserRole/CreateRole', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除后台管理账户 GET /api/UserRole/DeleteBackClientUser */
export async function deleteBackClientUser(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteBackClientUserParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/UserRole/DeleteBackClientUser', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 删除角色 GET /api/UserRole/DeleteRole */
export async function deleteRole(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteRoleParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/UserRole/DeleteRole', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 后台管理账户列表 POST /api/UserRole/GetBackClientUsers */
export async function getBackClientUsers(
  body: API.GetBackClientUsersInput,
  options?: API.RequestConfig
) {
  return request<API.UserDtoPageOutput>('/api/UserRole/GetBackClientUsers', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 角色列表 POST /api/UserRole/GetRoles */
export async function getRoles(body: API.GetRolesInput, options?: API.RequestConfig) {
  return request<API.RoleInfoPageOutput>('/api/UserRole/GetRoles', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 角色启用/禁用 POST /api/UserRole/RoleEnableOrForbid */
export async function roleEnableOrForbid(
  body: API.RoleEnableOrForbidInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/UserRole/RoleEnableOrForbid', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 后台管理账户编辑 POST /api/UserRole/UpdateBackClientUser */
export async function updateBackClientUser(
  body: API.UpdateBackClientUserInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/UserRole/UpdateBackClientUser', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 角色编辑 POST /api/UserRole/UpdateRole */
export async function updateRole(body: API.CreateOrUpdateRoleInput, options?: API.RequestConfig) {
  return request<number>('/api/UserRole/UpdateRole', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Wallet.ts

New file
@@ -0,0 +1,890 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 添加钱包开户回访记录 POST /api/Wallet/AddWalletAccountOpenFollow */
export async function addWalletAccountOpenFollow(
  body: API.AddWalletAccountOpenFollowInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/AddWalletAccountOpenFollow', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 提交银行钱包开户申请 POST /api/Wallet/ApplyBankWalletAccountOpen */
export async function applyBankWalletAccountOpen(
  body: API.ApplyBankWalletAccountOpenInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/ApplyBankWalletAccountOpen', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 申请批量付款 POST /api/Wallet/ApplyWalletBatchTransfer */
export async function applyWalletBatchTransfer(
  body: API.ApplyWalletBatchTransferInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/ApplyWalletBatchTransfer', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 发薪申请提交 POST /api/Wallet/ApplyWalletBatchTransferForOrderSettle */
export async function applyWalletBatchTransferForOrderSettle(
  body: API.ApplyWalletBatchTransferForOrderSettleInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/ApplyWalletBatchTransferForOrderSettle', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 充值申请 POST /api/Wallet/ApplyWalletRecharge */
export async function applyWalletRecharge(
  body: API.WalletRechargeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/ApplyWalletRecharge', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 提交对单转账申请 POST /api/Wallet/ApplyWalletSingleTransfer */
export async function applyWalletSingleTransfer(
  body: API.ApplyWalletSingleTransferInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/ApplyWalletSingleTransfer', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 对公转账提交 POST /api/Wallet/ApplyWalletSingleTransferForOrderSettle */
export async function applyWalletSingleTransferForOrderSettle(
  body: API.ApplyWalletSingleTransferForOrderSettleInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/ApplyWalletSingleTransferForOrderSettle', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 审核批量付款 POST /api/Wallet/AuditWalletBatchTransfer */
export async function auditWalletBatchTransfer(
  body: API.AuditWalletBatchTransferInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/AuditWalletBatchTransfer', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 审核批量付款明细 POST /api/Wallet/AuditWalletBatchTransferDetail */
export async function auditWalletBatchTransferDetail(
  body: API.AuditWalletBatchTransferDetailInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/AuditWalletBatchTransferDetail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 审核对单转账申请 POST /api/Wallet/AuditWalletSingleTransfer */
export async function auditWalletSingleTransfer(
  body: API.AuditWalletSingleTransferInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/AuditWalletSingleTransfer', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 审核线下支付申请 POST /api/Wallet/AuditWalletSingleTransferForOffline */
export async function auditWalletSingleTransferForOffline(
  body: API.AuditWalletSingleTransferInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/AuditWalletSingleTransferForOffline', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 计算批量付款手续费 POST /api/Wallet/CalculationWalletBatchImportTempPayFee */
export async function calculationWalletBatchImportTempPayFee(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIcalculationWalletBatchImportTempPayFeeParams,
  body: API.AddWalletBatchImportTempInput[],
  options?: API.RequestConfig
) {
  return request<API.AddWalletBatchImportTempInput[]>(
    '/api/Wallet/CalculationWalletBatchImportTempPayFee',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      params: {
        ...params,
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 计算付款手续费 POST /api/Wallet/CalculationWalletPayFee */
export async function calculationWalletPayFee(
  body: API.CalculationWalletPayFeeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/CalculationWalletPayFee', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 校验银行钱包开户验证码 POST /api/Wallet/CheckBankWalletAccountOpenVerificationCode */
export async function checkBankWalletAccountOpenVerificationCode(
  body: API.CheckPhoneVerificationCodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/CheckBankWalletAccountOpenVerificationCode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 审核充值申请 POST /api/Wallet/CheckWalletRecharge */
export async function checkWalletRecharge(
  body: API.CheckWalletRechargeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/CheckWalletRecharge', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 删除批量付款临时数据 GET /api/Wallet/DeleteWalletBatchImportTemp */
export async function deleteWalletBatchImportTemp(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIdeleteWalletBatchImportTempParams,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/DeleteWalletBatchImportTemp', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出用户平安银行流水明细列表 POST /api/Wallet/ExportGetUserPingAnTransactionRecordList */
export async function exportGetUserPingAnTransactionRecordList(
  body: API.QueryUserTransactionRecordPageInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Wallet/ExportGetUserPingAnTransactionRecordList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询所有银行下拉数据 POST /api/Wallet/GetAllBankDropdown */
export async function getAllBankDropdown(options?: API.RequestConfig) {
  return request<API.AllBankListOutput[]>('/api/Wallet/GetAllBankDropdown', {
    method: 'POST',
    ...(options || {}),
  });
}

/** 获取电子回单信息 GET /api/Wallet/GetElecBillInfo */
export async function getElecBillInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetElecBillInfoParams,
  options?: API.RequestConfig
) {
  return request<API.ElecBillInfoOutput>('/api/Wallet/GetElecBillInfo', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取批量付款临时数据分页列表 GET /api/Wallet/GetStatsWalletBatchTransferData */
export async function getStatsWalletBatchTransferData(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetStatsWalletBatchTransferDataParams,
  options?: API.RequestConfig
) {
  return request<API.DecimalDecimalValueTuple>('/api/Wallet/GetStatsWalletBatchTransferData', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取交易明细 POST /api/Wallet/GetUserTransactionDetailList */
export async function getUserTransactionDetailList(
  body: API.QueryWalletTransactionDetailList,
  options?: API.RequestConfig
) {
  return request<API.UserTransactionRecordListOutputPageOutput>(
    '/api/Wallet/GetUserTransactionDetailList',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取用户钱包流水明细详情信息 POST /api/Wallet/GetUserTransactionRecordDetail */
export async function getUserTransactionRecordDetail(
  body: API.QueryUserTransactionRecordDetailInput,
  options?: API.RequestConfig
) {
  return request<API.UserTransactionRecordDetailOutput>(
    '/api/Wallet/GetUserTransactionRecordDetail',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取用户流水明细分页列表 POST /api/Wallet/GetUserTransactionRecordPage */
export async function getUserTransactionRecordPage(
  body: API.QueryUserTransactionRecordPageInput,
  options?: API.RequestConfig
) {
  return request<API.UserTransactionRecordListOutputPageOutput>(
    '/api/Wallet/GetUserTransactionRecordPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 管理后台获取用户流水明细分页列表 POST /api/Wallet/GetUserTransactionRecordPageForAdmin */
export async function getUserTransactionRecordPageForAdmin(
  body: API.QueryUserTransactionRecordPageForAdminInput,
  options?: API.RequestConfig
) {
  return request<API.UserTransactionRecordListOutputPageOutput>(
    '/api/Wallet/GetUserTransactionRecordPageForAdmin',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 查询用户所有钱包账户类型的开通信息下拉数据 POST /api/Wallet/GetUserWalletAccountTypeOpenInfoDropdown */
export async function getUserWalletAccountTypeOpenInfoDropdown(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetUserWalletAccountTypeOpenInfoDropdownParams,
  options?: API.RequestConfig
) {
  return request<API.WalletAccountTypeOpenInfoOutput[]>(
    '/api/Wallet/GetUserWalletAccountTypeOpenInfoDropdown',
    {
      method: 'POST',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 查询用户所有钱包账户类型的开通信息下拉数据,支持支付通道设置配置 POST /api/Wallet/GetUserWalletAccountTypeOpenInfoDropdownForPay */
export async function getUserWalletAccountTypeOpenInfoDropdownForPay(
  body: API.GetUserWalletAccountTypeOpenInfoInput,
  options?: API.RequestConfig
) {
  return request<API.WalletAccountTypeOpenInfoOutput[]>(
    '/api/Wallet/GetUserWalletAccountTypeOpenInfoDropdownForPay',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 根据钱包账户类型获取用户钱包余额信息 POST /api/Wallet/GetUserWalletBalanceInfoByType */
export async function getUserWalletBalanceInfoByType(
  body: API.WalletAccountTypeEnum,
  options?: API.RequestConfig
) {
  return request<API.UserWalletBalanceInfoOutput>('/api/Wallet/GetUserWalletBalanceInfoByType', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取用户流水明细分页列表 POST /api/Wallet/GetUserWalletTransactionRecordPage */
export async function getUserWalletTransactionRecordPage(
  body: API.QueryUserTransactionRecordPageInput,
  options?: API.RequestConfig
) {
  return request<API.UserTransactionRecordListOutputPageOutput>(
    '/api/Wallet/GetUserWalletTransactionRecordPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取钱包开户详细信息 POST /api/Wallet/GetWalletAccountOpenDetail */
export async function getWalletAccountOpenDetail(
  body: API.BaseIdInput,
  options?: API.RequestConfig
) {
  return request<API.WalletAccountOpenDetailOutput>('/api/Wallet/GetWalletAccountOpenDetail', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取钱包开户回访分页列表 POST /api/Wallet/GetWalletAccountOpenFollowPage */
export async function getWalletAccountOpenFollowPage(
  body: API.QueryWalletAccountOpenFollowPageInput,
  options?: API.RequestConfig
) {
  return request<API.WalletAccountOpenFollowListOutputPageOutput>(
    '/api/Wallet/GetWalletAccountOpenFollowPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取钱包开户管理分页列表 POST /api/Wallet/GetWalletAccountOpenManagePage */
export async function getWalletAccountOpenManagePage(
  body: API.QueryWalletAccountOpenManagePageInput,
  options?: API.RequestConfig
) {
  return request<API.WalletAccountOpenManageListOutputPageOutput>(
    '/api/Wallet/GetWalletAccountOpenManagePage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取批量付款临时数据分页列表 POST /api/Wallet/GetWalletBatchImportTempPage */
export async function getWalletBatchImportTempPage(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWalletBatchImportTempPageParams,
  body: API.PageInput,
  options?: API.RequestConfig
) {
  return request<API.WalletBatchImportTempOutputPageOutput>(
    '/api/Wallet/GetWalletBatchImportTempPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      params: {
        ...params,
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取批量付款详情 GET /api/Wallet/GetWalletBatchTransferDetailInfo */
export async function getWalletBatchTransferDetailInfo(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWalletBatchTransferDetailInfoParams,
  options?: API.RequestConfig
) {
  return request<API.WalletBatchTransferDetailInfoOutput>(
    '/api/Wallet/GetWalletBatchTransferDetailInfo',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取批量付款明细列表 POST /api/Wallet/GetWalletBatchTransferDetailPage */
export async function getWalletBatchTransferDetailPage(
  body: API.QueryWalletBatchTransferDetailListInput,
  options?: API.RequestConfig
) {
  return request<API.WalletBatchTransferDetailListOutputPageOutput>(
    '/api/Wallet/GetWalletBatchTransferDetailPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取批量付款列表 POST /api/Wallet/GetWalletBatchTransferPage */
export async function getWalletBatchTransferPage(
  body: API.QueryWalletBatchTransferListInput,
  options?: API.RequestConfig
) {
  return request<API.WalletBatchTransferListOutputPageOutput>(
    '/api/Wallet/GetWalletBatchTransferPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 日账单明细 POST /api/Wallet/GetWalletDayDetailItemList */
export async function getWalletDayDetailItemList(
  body: API.QueryWalletDayDetailItemInput,
  options?: API.RequestConfig
) {
  return request<API.WalletDetailItemPageOutput>('/api/Wallet/GetWalletDayDetailItemList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询账户明细 GET /api/Wallet/GetWalletDetail */
export async function getWalletDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWalletDetailParams,
  options?: API.RequestConfig
) {
  return request<API.WalletBalanceDetailOutput>('/api/Wallet/GetWalletDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取账户管理列表 POST /api/Wallet/GetWalletMainList */
export async function getWalletMainList(
  body: API.QueryWalletMainListInput,
  options?: API.RequestConfig
) {
  return request<API.WalletMainListOutputPageOutput>('/api/Wallet/GetWalletMainList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 月账单明细 POST /api/Wallet/GetWalletMonthDetailItemList */
export async function getWalletMonthDetailItemList(
  body: API.QueryWalletMonthDetailItemInput,
  options?: API.RequestConfig
) {
  return request<API.WalletDetailItemPageOutput>('/api/Wallet/GetWalletMonthDetailItemList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取充值详情 GET /api/Wallet/GetWalletRechargeDetail */
export async function getWalletRechargeDetail(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWalletRechargeDetailParams,
  options?: API.RequestConfig
) {
  return request<API.WalletRechargeOutput>('/api/Wallet/GetWalletRechargeDetail', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 获取充值申请列表 POST /api/Wallet/GetWalletRechargeList */
export async function getWalletRechargeList(
  body: API.QueryWalletRechargeInput,
  options?: API.RequestConfig
) {
  return request<API.WalletRechargeOutputPageOutput>('/api/Wallet/GetWalletRechargeList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取对单转账详情 POST /api/Wallet/GetWalletSingleTransferDetail */
export async function getWalletSingleTransferDetail(
  body: API.BaseIdInput,
  options?: API.RequestConfig
) {
  return request<API.WalletSingleTransferDetailOutput>(
    '/api/Wallet/GetWalletSingleTransferDetail',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 获取对单转账分页列表 POST /api/Wallet/GetWalletSingleTransferPage */
export async function getWalletSingleTransferPage(
  body: API.QueryWalletSingleTransferPageInput,
  options?: API.RequestConfig
) {
  return request<API.WalletSingleTransferListOutputPageOutput>(
    '/api/Wallet/GetWalletSingleTransferPage',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 导入批量付款数据 POST /api/Wallet/ImportBatchTransferExcel */
export async function importBatchTransferExcel(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIimportBatchTransferExcelParams,
  body: API.PageInput,
  options?: API.RequestConfig
) {
  return request<API.WalletBatchImportTempOutputPageOutput>(
    '/api/Wallet/ImportBatchTransferExcel',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      params: {
        ...params,
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 支付宝充值查询 GET /api/Wallet/QueryRecharge */
export async function queryRecharge(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIqueryRechargeParams,
  options?: API.RequestConfig
) {
  return request<API.WalletRechargeStatusEnum>('/api/Wallet/QueryRecharge', {
    method: 'GET',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

/** 导出资金账单--日数据明细账单下载 POST /api/Wallet/QueryWalletDayDetailBillListForExport */
export async function queryWalletDayDetailBillListForExport(
  body: API.QueryWalletDetailBillInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Wallet/QueryWalletDayDetailBillListForExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 查询账户历史余额 POST /api/Wallet/QueryWalletDayHistoryBalance */
export async function queryWalletDayHistoryBalance(
  body: API.QueryWalletDayHistoryBalanceInput,
  options?: API.RequestConfig
) {
  return request<API.WalletDayHistoryBalanceOutputPageOutput>(
    '/api/Wallet/QueryWalletDayHistoryBalance',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      data: body,
      ...(options || {}),
    }
  );
}

/** 资金账单--日月数据明细 POST /api/Wallet/QueryWalletDetailBillList */
export async function queryWalletDetailBillList(
  body: API.QueryWalletDetailBillInput,
  options?: API.RequestConfig
) {
  return request<API.WalletDetailBillItemPageOutput>('/api/Wallet/QueryWalletDetailBillList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 资金账单---总额详情 POST /api/Wallet/QueryWalletDetailTotal */
export async function queryWalletDetailTotal(
  body: API.QueryWalletDetailBillInput,
  options?: API.RequestConfig
) {
  return request<API.WalletDetailTotalOutput>('/api/Wallet/QueryWalletDetailTotal', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 导出资金账单--月数据明细账单下载 POST /api/Wallet/QueryWalletMonthDetailBillListForExport */
export async function queryWalletMonthDetailBillListForExport(
  body: API.QueryWalletDetailBillInput,
  options?: API.RequestConfig
) {
  return request<any>('/api/Wallet/QueryWalletMonthDetailBillListForExport', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 录入钱包开户银行卡号 POST /api/Wallet/SetBankWalletAccountOpenAcctNo */
export async function setBankWalletAccountOpenAcctNo(
  body: API.SetBankWalletAccountOpenAcctNoInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/SetBankWalletAccountOpenAcctNo', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 上传钱包开户银行凭证 POST /api/Wallet/SetBankWalletAccountOpenBankCertUrl */
export async function setBankWalletAccountOpenBankCertUrl(
  body: API.SetBankWalletAccountOpenBankCertUrlInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/SetBankWalletAccountOpenBankCertUrl', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 录入钱包开户银行卡号 POST /api/Wallet/SetBankWalletAccountOpenOpentBankNode */
export async function setBankWalletAccountOpenOpentBankNode(
  body: API.SetBankWalletAccountOpenOpentBankNodeInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/SetBankWalletAccountOpenOpentBankNode', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置钱包状态 冻结 解冻 POST /api/Wallet/SetWalletMainStatus */
export async function setWalletMainStatus(
  body: API.SetWalletStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/SetWalletMainStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 修改批量付款临时数据 POST /api/Wallet/UpdateWalletBatchImportTemp */
export async function updateWalletBatchImportTemp(
  body: API.UpdateWalletBatchImportTempInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Wallet/UpdateWalletBatchImportTemp', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/WalletChannel.ts

New file
@@ -0,0 +1,59 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取支付通道手续费设置 GET /api/WalletChannel/GetWalletPayChannelFeeSettings */
export async function getWalletPayChannelFeeSettings(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APIgetWalletPayChannelFeeSettingsParams,
  options?: API.RequestConfig
) {
  return request<API.WalletPayChannelFeeSettingOutput[]>(
    '/api/WalletChannel/GetWalletPayChannelFeeSettings',
    {
      method: 'GET',
      params: {
        ...params,
      },
      ...(options || {}),
    }
  );
}

/** 获取支付通道配置 GET /api/WalletChannel/GetWalletPayChannelList */
export async function getWalletPayChannelList(options?: API.RequestConfig) {
  return request<API.WalletPayChannelOutput[]>('/api/WalletChannel/GetWalletPayChannelList', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 保存支付通道手续费 POST /api/WalletChannel/SaveWalletPayChannelFeeSetting */
export async function saveWalletPayChannelFeeSetting(
  body: API.SaveWalletPayChannelFeeSettingInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/WalletChannel/SaveWalletPayChannelFeeSetting', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 设置支付通过状态 POST /api/WalletChannel/SetWalletPayChannelStatus */
export async function setWalletPayChannelStatus(
  body: API.SetWalletPayChannelStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/WalletChannel/SetWalletPayChannelStatus', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/Withdraw.ts

New file
@@ -0,0 +1,94 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 获取用户是否添加银行账户 GET /api/Withdraw/CheckUserAccountIsSet */
export async function checkUserAccountIsSet(options?: API.RequestConfig) {
  return request<boolean>('/api/Withdraw/CheckUserAccountIsSet', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 创建或修改用户的账户信息 POST /api/Withdraw/CreateOrEditWithDrawAccount */
export async function createOrEditWithDrawAccount(
  body: API.CreateWithdrawAccountInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Withdraw/CreateOrEditWithDrawAccount', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 创建用户的提款申请 POST /api/Withdraw/CreateUserWithdrawAccount */
export async function createUserWithdrawAccount(
  body: API.CreateUserWithdrawInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Withdraw/CreateUserWithdrawAccount', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 获取当前用户的银行账号 GET /api/Withdraw/GetUserAccount */
export async function getUserAccount(options?: API.RequestConfig) {
  return request<API.GetUserAccountDto>('/api/Withdraw/GetUserAccount', {
    method: 'GET',
    ...(options || {}),
  });
}

/** 获取用户的 POST /api/Withdraw/GetUserWithdrawList */
export async function getUserWithdrawList(
  body: API.GetUserWithdrawInput,
  options?: API.RequestConfig
) {
  return request<API.UserWithdrawDtoPageOutput>('/api/Withdraw/GetUserWithdrawList', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 驳回提现申请 POST /api/Withdraw/RejectUserWithdraw */
export async function rejectUserWithdraw(
  body: API.SetUserWithdrawStatusInput,
  options?: API.RequestConfig
) {
  return request<number>('/api/Withdraw/RejectUserWithdraw', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

/** 提现完成 POST /api/Withdraw/SetUserWithdrawComplete */
export async function setUserWithdrawComplete(
  body: API.SetUserWithdrawComplete,
  options?: API.RequestConfig
) {
  return request<number>('/api/Withdraw/SetUserWithdrawComplete', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/WxNotify.ts

New file
@@ -0,0 +1,33 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 此处后端没有提供注释 POST /api/WxNotify/TencentIMCallbackHandler */
export async function tencentIMCallbackHandler(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.APItencentIMCallbackHandlerParams,
  options?: API.RequestConfig
) {
  return request<API.TencentIMCallbackOutput>('/api/WxNotify/TencentIMCallbackHandler', {
    method: 'POST',
    params: {
      ...params,
    },
    ...(options || {}),
  });
}

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

 src/services/api/WxPayNotify.ts

New file
@@ -0,0 +1,18 @@
/* eslint-disable */
// @ts-ignore
import { request } from '@/utils/request';

/** 微信支付回调通知 POST /api/WxPayNotify/WxRechargeNotify */
export async function wxRechargeNotify(
  body: API.WxRechargeNotifyInput,
  options?: API.RequestConfig
) {
  return request<API.WxRechargeNotifyResult>('/api/WxPayNotify/WxRechargeNotify', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    data: body,
    ...(options || {}),
  });
}

 src/services/api/index.ts

@@ -5,34 +5,170 @@
import * as AbpApiDefinition from './AbpApiDefinition';
import * as AbpApplicationConfiguration from './AbpApplicationConfiguration';
import * as Account from './Account';
import * as AdvertiseBoard from './AdvertiseBoard';
import * as AdvertiseOnShow from './AdvertiseOnShow';
import * as Alipay from './Alipay';
import * as AlipayEcsignNotify from './AlipayEcsignNotify';
import * as AliPayNotify from './AliPayNotify';
import * as Area from './Area';
import * as BaseModule from './BaseModule';
import * as BestSign from './BestSign';
import * as BestSignCallBack from './BestSignCallBack';
import * as CaiNiao from './CaiNiao';
import * as CaiNiaoCallBack from './CaiNiaoCallBack';
import * as CircleFriend from './CircleFriend';
import * as Common from './Common';
import * as CompanyInsure from './CompanyInsure';
import * as Consult from './Consult';
import * as CooperationApply from './CooperationApply';
import * as Customer from './Customer';
import * as EnterpriseMaterial from './EnterpriseMaterial';
import * as Features from './Features';
import * as FirstPartyCompany from './FirstPartyCompany';
import * as Fund from './Fund';
import * as HeadHunter from './HeadHunter';
import * as HelpQuestion from './HelpQuestion';
import * as IdentityRole from './IdentityRole';
import * as IdentityUser from './IdentityUser';
import * as IdentityUserLookup from './IdentityUserLookup';
import * as InsuranceClaim from './InsuranceClaim';
import * as InsuranceOrder from './InsuranceOrder';
import * as IncentivePayments from './IncentivePayments';
import * as IndustrialPark from './IndustrialPark';
import * as IndustryBody from './IndustryBody';
import * as IndustryMating from './IndustryMating';
import * as Information from './Information';
import * as Insurance from './Insurance';
import * as InsureConsult from './InsureConsult';
import * as InsureMarketProduct from './InsureMarketProduct';
import * as InsureOfflineBill from './InsureOfflineBill';
import * as InsureOrganization from './InsureOrganization';
import * as InsureSupplier from './InsureSupplier';
import * as LgGigWorker from './LgGigWorker';
import * as LgGigWorkerCustomerTemplateParam from './LgGigWorkerCustomerTemplateParam';
import * as LgGigWorkerReCharge from './LgGigWorkerReCharge';
import * as LgGigWorkerSignChannelSetting from './LgGigWorkerSignChannelSetting';
import * as LgGigWorkerSignFreeSetting from './LgGigWorkerSignFreeSetting';
import * as LgGigWorkerSignSetting from './LgGigWorkerSignSetting';
import * as Message from './Message';
import * as OpenInformation from './OpenInformation';
import * as OperateHistory from './OperateHistory';
import * as Order from './Order';
import * as ParkOrHR from './ParkOrHR';
import * as ParkReward from './ParkReward';
import * as Permissions from './Permissions';
import * as PhoneMessage from './PhoneMessage';
import * as PhonMessageHistory from './PhonMessageHistory';
import * as PingAn from './PingAn';
import * as PingAnBEDL from './PingAnBEDL';
import * as PingAnELCP from './PingAnELCP';
import * as PingAnJGF from './PingAnJGF';
import * as PlatformServicePay from './PlatformServicePay';
import * as PlatUserAccountSetting from './PlatUserAccountSetting';
import * as Product from './Product';
import * as Profile from './Profile';
import * as Purchase from './Purchase';
import * as Recharge from './Recharge';
import * as Resource from './Resource';
import * as SearchSetting from './SearchSetting';
import * as Setting from './Setting';
import * as Statistics from './Statistics';
import * as SysOrg from './SysOrg';
import * as SystemNotice from './SystemNotice';
import * as Tenant from './Tenant';
import * as TencentUser from './TencentUser';
import * as Test from './Test';
import * as ThirdPartCallBack from './ThirdPartCallBack';
import * as Training from './Training';
import * as User from './User';
import * as UserRole from './UserRole';
import * as Version from './Version';
import * as Wallet from './Wallet';
import * as WalletChannel from './WalletChannel';
import * as Withdraw from './Withdraw';
import * as WxNotify from './WxNotify';
import * as WxPayNotify from './WxPayNotify';
export default {
  AbpApiDefinition,
  AbpApplicationConfiguration,
  Account,
  AdvertiseBoard,
  AdvertiseOnShow,
  Alipay,
  AlipayEcsignNotify,
  AliPayNotify,
  Area,
  BaseModule,
  BestSign,
  BestSignCallBack,
  CaiNiao,
  CaiNiaoCallBack,
  CircleFriend,
  Common,
  CompanyInsure,
  Consult,
  CooperationApply,
  Customer,
  EnterpriseMaterial,
  Features,
  FirstPartyCompany,
  Fund,
  HeadHunter,
  HelpQuestion,
  IdentityRole,
  IdentityUser,
  IdentityUserLookup,
  InsuranceClaim,
  InsuranceOrder,
  IncentivePayments,
  IndustrialPark,
  IndustryBody,
  IndustryMating,
  Information,
  Insurance,
  InsureConsult,
  InsureMarketProduct,
  InsureOfflineBill,
  InsureOrganization,
  InsureSupplier,
  LgGigWorker,
  LgGigWorkerCustomerTemplateParam,
  LgGigWorkerReCharge,
  LgGigWorkerSignChannelSetting,
  LgGigWorkerSignFreeSetting,
  LgGigWorkerSignSetting,
  Message,
  OpenInformation,
  OperateHistory,
  Order,
  ParkOrHR,
  ParkReward,
  Permissions,
  PhoneMessage,
  PhonMessageHistory,
  PingAn,
  PingAnBEDL,
  PingAnELCP,
  PingAnJGF,
  PlatformServicePay,
  PlatUserAccountSetting,
  Product,
  Profile,
  Purchase,
  Recharge,
  Resource,
  SearchSetting,
  Setting,
  Statistics,
  SysOrg,
  SystemNotice,
  Tenant,
  TencentUser,
  Test,
  ThirdPartCallBack,
  Training,
  User,
  UserRole,
  Version,
  Wallet,
  WalletChannel,
  Withdraw,
  WxNotify,
  WxPayNotify,
};

 src/services/api/typings.d.ts

Diff too large