WEB/src/servers/api/siteApi.ts

// @ts-ignore
/* eslint-disable */
import { request } from 'umi';

/** 此处后端没有提供注释 GET /site-api/${param0}/customers */
export async function siteapicontrollerGetcustomers(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetcustomersParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedCustomerPaginationDTO>(
    `/site-api/${param0}/customers`,
    {
      method: 'GET',
      params: {
        ...queryParams,
        where: undefined,
        ...queryParams['where'],
        order: undefined,
        ...queryParams['order'],
      },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 POST /site-api/${param0}/customers */
export async function siteapicontrollerCreatecustomer(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerCreatecustomerParams,
  body: API.UnifiedCustomerDTO,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedCustomerDTO>(`/site-api/${param0}/customers`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/customers/batch */
export async function siteapicontrollerBatchcustomers(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerBatchcustomersParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param0}/customers/batch`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/customers/export */
export async function siteapicontrollerExportcustomers(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerExportcustomersParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<any>(`/site-api/${param0}/customers/export`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/customers/import */
export async function siteapicontrollerImportcustomers(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerImportcustomersParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param0}/customers/import`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/media */
export async function siteapicontrollerGetmedia(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetmediaParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedMediaPaginationDTO>(`/site-api/${param0}/media`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/media/batch */
export async function siteapicontrollerBatchmedia(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerBatchmediaParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param0}/media/batch`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/media/convert-webp */
export async function siteapicontrollerConvertmediatowebp(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerConvertmediatowebpParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(
    `/site-api/${param0}/media/convert-webp`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'text/plain',
      },
      params: { ...queryParams },
      data: body,
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 GET /site-api/${param0}/media/export */
export async function siteapicontrollerExportmedia(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerExportmediaParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<any>(`/site-api/${param0}/media/export`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/orders */
export async function siteapicontrollerGetorders(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetordersParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedOrderPaginationDTO>(`/site-api/${param0}/orders`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/orders */
export async function siteapicontrollerCreateorder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerCreateorderParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedOrderDTO>(`/site-api/${param0}/orders`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/orders/batch */
export async function siteapicontrollerBatchorders(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerBatchordersParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param0}/orders/batch`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/orders/export */
export async function siteapicontrollerExportorders(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerExportordersParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<any>(`/site-api/${param0}/orders/export`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/orders/import */
export async function siteapicontrollerImportorders(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerImportordersParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param0}/orders/import`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/products */
export async function siteapicontrollerGetproducts(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetproductsParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedProductPaginationDTO>(
    `/site-api/${param0}/products`,
    {
      method: 'GET',
      params: {
        ...queryParams,
        where: undefined,
        ...queryParams['where'],
        order: undefined,
        ...queryParams['order'],
      },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 POST /site-api/${param0}/products */
export async function siteapicontrollerCreateproduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerCreateproductParams,
  body: API.UnifiedProductDTO,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedProductDTO>(`/site-api/${param0}/products`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/products/batch */
export async function siteapicontrollerBatchproducts(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerBatchproductsParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param0}/products/batch`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/products/export */
export async function siteapicontrollerExportproducts(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerExportproductsParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<any>(`/site-api/${param0}/products/export`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/products/export-special */
export async function siteapicontrollerExportproductsspecial(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerExportproductsspecialParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<any>(`/site-api/${param0}/products/export-special`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/products/import */
export async function siteapicontrollerImportproducts(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerImportproductsParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param0}/products/import`, {
    method: 'POST',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 POST /site-api/${param0}/products/import-special */
export async function siteapicontrollerImportproductsspecial(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerImportproductsspecialParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<Record<string, any>>(
    `/site-api/${param0}/products/import-special`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'text/plain',
      },
      params: { ...queryParams },
      data: body,
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 GET /site-api/${param0}/reviews */
export async function siteapicontrollerGetreviews(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetreviewsParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedReviewPaginationDTO>(
    `/site-api/${param0}/reviews`,
    {
      method: 'GET',
      params: {
        ...queryParams,
        where: undefined,
        ...queryParams['where'],
        order: undefined,
        ...queryParams['order'],
      },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 POST /site-api/${param0}/reviews */
export async function siteapicontrollerCreatereview(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerCreatereviewParams,
  body: API.CreateReviewDTO,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedReviewDTO>(`/site-api/${param0}/reviews`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param0}/subscriptions */
export async function siteapicontrollerGetsubscriptions(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetsubscriptionsParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<API.UnifiedSubscriptionPaginationDTO>(
    `/site-api/${param0}/subscriptions`,
    {
      method: 'GET',
      params: {
        ...queryParams,
        where: undefined,
        ...queryParams['where'],
        order: undefined,
        ...queryParams['order'],
      },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 GET /site-api/${param0}/subscriptions/export */
export async function siteapicontrollerExportsubscriptions(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerExportsubscriptionsParams,
  options?: { [key: string]: any },
) {
  const { siteId: param0, ...queryParams } = params;
  return request<any>(`/site-api/${param0}/subscriptions/export`, {
    method: 'GET',
    params: {
      ...queryParams,
      where: undefined,
      ...queryParams['where'],
      order: undefined,
      ...queryParams['order'],
    },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param1}/customers/${param0} */
export async function siteapicontrollerGetcustomer(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetcustomerParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<API.UnifiedCustomerDTO>(
    `/site-api/${param1}/customers/${param0}`,
    {
      method: 'GET',
      params: { ...queryParams },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 PUT /site-api/${param1}/customers/${param0} */
export async function siteapicontrollerUpdatecustomer(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerUpdatecustomerParams,
  body: API.UnifiedCustomerDTO,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<API.UnifiedCustomerDTO>(
    `/site-api/${param1}/customers/${param0}`,
    {
      method: 'PUT',
      headers: {
        'Content-Type': 'application/json',
      },
      params: { ...queryParams },
      data: body,
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 DELETE /site-api/${param1}/customers/${param0} */
export async function siteapicontrollerDeletecustomer(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerDeletecustomerParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(
    `/site-api/${param1}/customers/${param0}`,
    {
      method: 'DELETE',
      params: { ...queryParams },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 GET /site-api/${param1}/customers/${param0}/orders */
export async function siteapicontrollerGetcustomerorders(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetcustomerordersParams,
  options?: { [key: string]: any },
) {
  const { customerId: param0, siteId: param1, ...queryParams } = params;
  return request<API.UnifiedOrderPaginationDTO>(
    `/site-api/${param1}/customers/${param0}/orders`,
    {
      method: 'GET',
      params: {
        ...queryParams,
        where: undefined,
        ...queryParams['where'],
        order: undefined,
        ...queryParams['order'],
      },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 PUT /site-api/${param1}/media/${param0} */
export async function siteapicontrollerUpdatemedia(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerUpdatemediaParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param1}/media/${param0}`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 DELETE /site-api/${param1}/media/${param0} */
export async function siteapicontrollerDeletemedia(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerDeletemediaParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param1}/media/${param0}`, {
    method: 'DELETE',
    params: { ...queryParams },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param1}/orders/${param0} */
export async function siteapicontrollerGetorder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetorderParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<API.UnifiedOrderDTO>(`/site-api/${param1}/orders/${param0}`, {
    method: 'GET',
    params: { ...queryParams },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 PUT /site-api/${param1}/orders/${param0} */
export async function siteapicontrollerUpdateorder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerUpdateorderParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param1}/orders/${param0}`, {
    method: 'PUT',
    headers: {
      'Content-Type': 'text/plain',
    },
    params: { ...queryParams },
    data: body,
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 DELETE /site-api/${param1}/orders/${param0} */
export async function siteapicontrollerDeleteorder(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerDeleteorderParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param1}/orders/${param0}`, {
    method: 'DELETE',
    params: { ...queryParams },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 GET /site-api/${param1}/orders/${param0}/notes */
export async function siteapicontrollerGetordernotes(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetordernotesParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(
    `/site-api/${param1}/orders/${param0}/notes`,
    {
      method: 'GET',
      params: { ...queryParams },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 POST /site-api/${param1}/orders/${param0}/notes */
export async function siteapicontrollerCreateordernote(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerCreateordernoteParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(
    `/site-api/${param1}/orders/${param0}/notes`,
    {
      method: 'POST',
      headers: {
        'Content-Type': 'text/plain',
      },
      params: { ...queryParams },
      data: body,
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 GET /site-api/${param1}/products/${param0} */
export async function siteapicontrollerGetproduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerGetproductParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<API.UnifiedProductDTO>(
    `/site-api/${param1}/products/${param0}`,
    {
      method: 'GET',
      params: { ...queryParams },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 PUT /site-api/${param1}/products/${param0} */
export async function siteapicontrollerUpdateproduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerUpdateproductParams,
  body: API.UnifiedProductDTO,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<API.UnifiedProductDTO>(
    `/site-api/${param1}/products/${param0}`,
    {
      method: 'PUT',
      headers: {
        'Content-Type': 'application/json',
      },
      params: { ...queryParams },
      data: body,
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 DELETE /site-api/${param1}/products/${param0} */
export async function siteapicontrollerDeleteproduct(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerDeleteproductParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(
    `/site-api/${param1}/products/${param0}`,
    {
      method: 'DELETE',
      params: { ...queryParams },
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 PUT /site-api/${param1}/reviews/${param0} */
export async function siteapicontrollerUpdatereview(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerUpdatereviewParams,
  body: API.UpdateReviewDTO,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<API.UnifiedReviewDTO>(
    `/site-api/${param1}/reviews/${param0}`,
    {
      method: 'PUT',
      headers: {
        'Content-Type': 'application/json',
      },
      params: { ...queryParams },
      data: body,
      ...(options || {}),
    },
  );
}

/** 此处后端没有提供注释 DELETE /site-api/${param1}/reviews/${param0} */
export async function siteapicontrollerDeletereview(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerDeletereviewParams,
  options?: { [key: string]: any },
) {
  const { id: param0, siteId: param1, ...queryParams } = params;
  return request<Record<string, any>>(`/site-api/${param1}/reviews/${param0}`, {
    method: 'DELETE',
    params: { ...queryParams },
    ...(options || {}),
  });
}

/** 此处后端没有提供注释 PUT /site-api/${param2}/products/${param1}/variations/${param0} */
export async function siteapicontrollerUpdatevariation(
  // 叠加生成的Param类型 (非body参数swagger默认没有生成对象)
  params: API.siteapicontrollerUpdatevariationParams,
  body: Record<string, any>,
  options?: { [key: string]: any },
) {
  const {
    variationId: param0,
    productId: param1,
    siteId: param2,
    ...queryParams
  } = params;
  return request<Record<string, any>>(
    `/site-api/${param2}/products/${param1}/variations/${param0}`,
    {
      method: 'PUT',
      headers: {
        'Content-Type': 'text/plain',
      },
      params: { ...queryParams },
      data: body,
      ...(options || {}),
    },
  );
}