import {
  currentUser,
  genealogies,
  publicGenealogies,
  notifications,
  joinApplications,
  listFamilyFeedFixtures,
  listFamilyArticleFixtures,
  listFamilyAlbumFixtures,
  listCeremonyFixtures,
  listGrowthRecordFixtures,
  listNotificationFixtures
} from '@/data/mock.js'
import { hasRemoteConfig, resolveRuntimeMode, runtimeConfig } from '@/utils/config.js'
import { AUTH_VERIFICATION_OPERATION, assertSmsCode } from '@/utils/auth-verification.js'
import { GENEALOGY_ACCESS_PRESET, fromApiGenealogyAccess } from '@/utils/genealogy-contracts.js'
import { session } from '@/utils/session.js'

const successCodes = [0, 200]
const REQUEST_TIMEOUT_MS = 15000

const createRequestError = (message, code, details = {}) => {
  const error = new Error(message)
  error.code = code
  Object.assign(error, details)
  return error
}

const createRequestCancelledError = () => createRequestError('请求已取消', 'REQUEST_CANCELLED')

// 页面只持有这个窄控制器，不直接依赖各端 RequestTask 的实现差异。
// request() 是唯一绑定/释放 owner；离页时 abort() 会同时拒绝等待中的 Promise，
// 因而页面不会在已销毁后继续处理成功回调。
export const createRequestController = () => {
  let abortCurrent = null
  return {
    bind(abortRequest) {
      if (typeof abortRequest !== 'function') throw new TypeError('请求中止器必须是函数')
      if (abortCurrent) abortCurrent()
      abortCurrent = abortRequest
    },
    release(abortRequest) {
      if (abortCurrent === abortRequest) abortCurrent = null
    },
    abort() {
      const abortRequest = abortCurrent
      abortCurrent = null
      if (abortRequest) abortRequest()
    }
  }
}

export const isRequestCancelled = (error) => error?.code === 'REQUEST_CANCELLED'

const isAuthenticatedSessionRejected = (error) =>
  error?.code === 'BUSINESS_ERROR' && Number(error.businessCode) === 401

let authenticationRecoveryInFlight = false

const recoverExpiredAuthenticatedSession = () => {
  if (authenticationRecoveryInFlight) return
  authenticationRecoveryInFlight = true
  session.clear()
  try {
    uni.reLaunch({
      url: '/pages/auth/a01-entry',
      complete: () => {
        authenticationRecoveryInFlight = false
      }
    })
  } catch {
    authenticationRecoveryInFlight = false
  }
}

export const unwrapResponse = (response) => {
  if (!response || typeof response !== 'object' || Array.isArray(response)) return response
  if (!Object.prototype.hasOwnProperty.call(response, 'code')) return response
  if (!successCodes.includes(Number(response.code))) {
    const numericCode = Number(response.code)
    throw createRequestError(response.msg || '请求未成功', 'BUSINESS_ERROR', {
      businessCode: Number.isNaN(numericCode) ? response.code : numericCode
    })
  }
  return Object.prototype.hasOwnProperty.call(response, 'data') ? response.data : response
}

const request = (options, {
  authenticated = true,
  strictEnvelope = false,
  requireEnvelopeData = false,
  expectedStatus = null,
  requestController = null
} = {}) => new Promise((resolve, reject) => {
  if (requestController !== null && (
    typeof requestController.bind !== 'function' ||
    typeof requestController.release !== 'function'
  )) {
    reject(new TypeError('请求控制器格式无效'))
    return
  }
  let settled = false
  let requestTask = null
  const release = () => requestController?.release(abortRequest)
  const resolveOnce = (value) => {
    if (settled) return
    settled = true
    release()
    resolve(value)
  }
  const rejectOnce = (error) => {
    if (settled) return
    settled = true
    release()
    reject(error)
  }
  const abortRequest = () => {
    if (settled) return
    const task = requestTask
    rejectOnce(createRequestCancelledError())
    task?.abort?.()
  }
  const token = session.getToken()
  requestTask = uni.request({
    ...options,
    url: `${runtimeConfig.baseUrl}${options.url}`,
    header: {
      clientid: runtimeConfig.clientId,
      tenantId: runtimeConfig.tenantId,
      ...(authenticated && token ? { Authorization: `Bearer ${token}` } : {}),
      ...(options.header || {})
    },
    success: ({ data, statusCode }) => {
      if (expectedStatus !== null && statusCode !== expectedStatus) {
        rejectOnce(createRequestError(
          `服务只接受 HTTP ${expectedStatus} 响应，实际为 ${statusCode}`,
          'HTTP_ERROR',
          { httpStatus: statusCode }
        ))
        return
      }
      if (statusCode < 200 || statusCode >= 300) {
        rejectOnce(createRequestError(
          data?.msg || `请求失败（${statusCode}）`,
          'HTTP_ERROR',
          { httpStatus: statusCode }
        ))
        return
      }
      if (
        strictEnvelope &&
        (!data ||
          typeof data !== 'object' ||
          Array.isArray(data) ||
          !Object.prototype.hasOwnProperty.call(data, 'code') ||
          !Number.isInteger(data.code) ||
          (requireEnvelopeData && !Object.prototype.hasOwnProperty.call(data, 'data')))
      ) {
        rejectOnce(createRequestError('服务响应格式无效', 'RESPONSE_INVALID'))
        return
      }
      try {
        resolveOnce(unwrapResponse(data))
      } catch (error) {
        // 业务 401 表示本地会话已经失效：只撤销本地令牌和家谱上下文，
        // 不调用退出接口、不重试写操作，也不影响未携带会话的登录/注册请求。
        if (authenticated && isAuthenticatedSessionRejected(error)) {
          recoverExpiredAuthenticatedSession()
        }
        rejectOnce(error)
      }
    },
    fail: (error) => {
      const message = error?.errMsg || '网络连接失败'
      rejectOnce(createRequestError(
        message,
        /timeout/i.test(message) ? 'REQUEST_TIMEOUT' : 'NETWORK_ERROR'
      ))
    }
  })
  if (!settled && requestController) requestController.bind(abortRequest)
})

// 已核对接口使用这一严格边界：只接受 HTTP 200 与完整 JSON envelope，
// 并统一限制弱网等待时间。尚未逐页治理的旧业务读取仍沿用上方通用 request。
const requestStrict = (options, {
  authenticated = true,
  requireData = true,
  requestController = null
} = {}) => request({
  ...options,
  timeout: REQUEST_TIMEOUT_MS
}, {
  authenticated,
  strictEnvelope: true,
  requireEnvelopeData: requireData,
  expectedStatus: 200,
  requestController
})

const requestAuth = (options, { requestController = null } = {}) => requestStrict(options, {
  authenticated: false,
  requestController
})

// RVoid 的 OpenAPI schema 没有把 data 声明为必填。空结果接口仍要求合法的
// HTTP 200 与整数 code，但统一向页面返回 null，避免把 envelope 本身泄漏成业务数据。
const requestAuthVoid = async (options, { requestController = null } = {}) => {
  await requestStrict(options, {
    authenticated: false,
    requireData: false,
    requestController
  })
  return null
}

const parseStrictUploadResponse = (responseText, requireData) => {
  let data
  try {
    data = JSON.parse(responseText)
  } catch {
    throw createRequestError('文件服务响应格式无效', 'RESPONSE_INVALID')
  }
  if (
    !data ||
    typeof data !== 'object' ||
    Array.isArray(data) ||
    !Object.prototype.hasOwnProperty.call(data, 'code') ||
    !Number.isInteger(data.code) ||
    (requireData && !Object.prototype.hasOwnProperty.call(data, 'data'))
  ) {
    throw createRequestError('文件服务响应格式无效', 'RESPONSE_INVALID')
  }
  return unwrapResponse(data)
}

const requestNativeFileChunk = ({ uploadId, chunkIndex, chunkMd5, filePath }, { requestController = null } = {}) => new Promise((resolve, reject) => {
  if (typeof globalThis.uni?.uploadFile !== 'function') {
    reject(createRequestError('当前运行环境不支持文件上传', 'FILE_UPLOAD_UNAVAILABLE'))
    return
  }
  if (requestController !== null && (
    typeof requestController.bind !== 'function' ||
    typeof requestController.release !== 'function'
  )) {
    reject(new TypeError('文件上传控制器格式无效'))
    return
  }
  let settled = false
  let task = null
  let cancelled = false
  const release = () => requestController?.release(abort)
  const resolveOnce = (value) => {
    if (settled) return
    settled = true
    release()
    resolve(value)
  }
  const rejectOnce = (error) => {
    if (settled) return
    settled = true
    release()
    reject(error)
  }
  const abort = () => {
    if (settled) return
    cancelled = true
    task?.abort?.()
    rejectOnce(createRequestCancelledError())
  }
  const token = session.getToken()
  try {
    task = globalThis.uni.uploadFile({
      url: `${runtimeConfig.baseUrl}/genealogy/app/files/resumable/chunk`,
      filePath,
      name: 'file',
      formData: {
        uploadId,
        chunkIndex: String(chunkIndex),
        chunkMd5
      },
      header: {
        clientid: runtimeConfig.clientId,
        tenantId: runtimeConfig.tenantId,
        ...(token ? { Authorization: `Bearer ${token}` } : {})
      },
      timeout: REQUEST_TIMEOUT_MS,
      success: (upload) => {
        if (upload.statusCode !== 200) {
          rejectOnce(createRequestError(`文件分片上传失败（HTTP ${upload.statusCode}）`, 'HTTP_ERROR', { httpStatus: upload.statusCode }))
          return
        }
        try {
          parseStrictUploadResponse(upload.data, false)
          resolveOnce(null)
        } catch (error) {
          rejectOnce(error)
        }
      },
      fail: (error) => {
        if (settled) return
        if (cancelled) {
          rejectOnce(createRequestCancelledError())
          return
        }
        const message = typeof error?.errMsg === 'string' && error.errMsg
          ? error.errMsg
          : '文件分片上传失败'
        const timeout = /timeout/i.test(message)
        rejectOnce(createRequestError(
          timeout ? '文件分片上传超时' : message,
          timeout ? 'REQUEST_TIMEOUT' : 'UPLOAD_FAILED'
        ))
      }
    })
    if (requestController) requestController.bind(abort)
  } catch (error) {
    rejectOnce(error)
  }
})

const requestBrowserFileChunk = ({ uploadId, chunkIndex, chunkMd5, file }, { requestController = null } = {}) => new Promise((resolve, reject) => {
  if (typeof globalThis.fetch !== 'function' || typeof globalThis.FormData !== 'function') {
    reject(createRequestError('当前运行环境不支持文件上传', 'FILE_UPLOAD_UNAVAILABLE'))
    return
  }
  if (requestController !== null && (
    typeof requestController.bind !== 'function' ||
    typeof requestController.release !== 'function'
  )) {
    reject(new TypeError('文件上传控制器格式无效'))
    return
  }
  let settled = false
  let timeoutId = null
  const abortController = new AbortController()
  const release = () => requestController?.release(abort)
  const clearRequestTimeout = () => {
    if (timeoutId === null) return
    clearTimeout(timeoutId)
    timeoutId = null
  }
  const resolveOnce = (value) => {
    if (settled) return
    settled = true
    clearRequestTimeout()
    release()
    resolve(value)
  }
  const rejectOnce = (error) => {
    if (settled) return
    settled = true
    clearRequestTimeout()
    release()
    reject(error)
  }
  const abort = () => {
    if (settled) return
    abortController.abort()
    rejectOnce(createRequestCancelledError())
  }
  const token = session.getToken()
  const formData = new globalThis.FormData()
  formData.append('uploadId', uploadId)
  formData.append('chunkIndex', String(chunkIndex))
  formData.append('chunkMd5', chunkMd5)
  formData.append('file', file, file.name || 'image')
  if (requestController) requestController.bind(abort)
  timeoutId = setTimeout(() => {
    abortController.abort()
    rejectOnce(createRequestError('文件分片上传超时', 'REQUEST_TIMEOUT'))
  }, REQUEST_TIMEOUT_MS)
  globalThis.fetch(`${runtimeConfig.baseUrl}/genealogy/app/files/resumable/chunk`, {
    method: 'POST',
    headers: {
      clientid: runtimeConfig.clientId,
      tenantId: runtimeConfig.tenantId,
      ...(token ? { Authorization: `Bearer ${token}` } : {})
    },
    body: formData,
    signal: abortController.signal
  }).then(async (response) => {
    if (response.status !== 200) {
      throw createRequestError(`文件分片上传失败（HTTP ${response.status}）`, 'HTTP_ERROR', { httpStatus: response.status })
    }
    parseStrictUploadResponse(await response.text(), false)
    resolveOnce(null)
  }).catch((error) => {
    if (settled) return
    rejectOnce(error?.name === 'AbortError' ? createRequestCancelledError() : error)
  })
})

const requireRemoteAuth = () => {
  if (resolveRuntimeMode() !== 'remote') {
    const error = new Error('当前为本地预览模式，真实认证服务未启用')
    error.code = 'AUTH_REMOTE_REQUIRED'
    throw error
  }
}

const assertAuthVerificationOperation = (operationCode) => {
  if (!Object.values(AUTH_VERIFICATION_OPERATION).includes(operationCode)) {
    throw new TypeError('认证动作不属于当前认证合同')
  }
  return operationCode
}

const assertValidToken = (validToken) => {
  if (typeof validToken !== 'string' || !validToken.trim()) {
    throw new TypeError('发送短信前必须取得有效的行为验证票据')
  }
  return validToken.trim()
}

const normalizeOptionalValidToken = (validToken) =>
  validToken === undefined ? undefined : assertValidToken(validToken)

const assertPasswordHash = (passwordHash) => {
  if (typeof passwordHash !== 'string' || !/^[a-f0-9]{32}$/.test(passwordHash)) {
    throw new TypeError('密码摘要必须是 32 位小写 MD5')
  }
  return passwordHash
}

const normalizeOptionalAuthText = (value, label) => {
  if (value === undefined || value === null) return undefined
  if (typeof value !== 'string') {
    throw new TypeError(`${label}必须是字符串`)
  }
  const normalized = value.trim()
  return normalized || undefined
}

const normalizeProfileResponseText = (value, field) => {
  if (value === undefined || value === null) return ''
  if (typeof value !== 'string') {
    throw createRequestError(`个人资料字段 ${field} 无效`, 'PROFILE_RESPONSE_INVALID')
  }
  return value.trim()
}

const normalizeProfileAvatar = (value) => {
  if (value === undefined || value === null || value === '') return null
  const numericValue = typeof value === 'string' && /^-?\d+$/.test(value)
    ? Number(value)
    : value
  if (Number.isSafeInteger(numericValue) && numericValue <= 0) return null
  return Number.isSafeInteger(numericValue) ? numericValue : null
}

const normalizeProfileUserId = (value) => {
  if (value === undefined || value === null || value === '') return ''
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw createRequestError('个人资料字段 userId 无效', 'PROFILE_RESPONSE_INVALID')
}

const normalizeAppProfile = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
    throw createRequestError('个人资料响应格式无效', 'PROFILE_RESPONSE_INVALID')
  }
  return {
    userId: normalizeProfileUserId(payload.userId),
    tenantId: normalizeProfileResponseText(payload.tenantId, 'tenantId'),
    userNo: normalizeProfileResponseText(payload.userNo, 'userNo'),
    phone: normalizeProfileResponseText(payload.phone, 'phone'),
    nickName: normalizeProfileResponseText(payload.nickName, 'nickName'),
    realName: normalizeProfileResponseText(payload.realName, 'realName'),
    avatar: normalizeProfileAvatar(payload.avatar),
    sex: normalizeProfileResponseText(payload.sex, 'sex'),
    birthday: normalizeProfileResponseText(payload.birthday, 'birthday'),
    email: normalizeProfileResponseText(payload.email, 'email'),
    registerSource: normalizeProfileResponseText(payload.registerSource, 'registerSource'),
    status: normalizeProfileResponseText(payload.status, 'status')
  }
}

const normalizeProfileUpdatePayload = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload) || Object.getPrototypeOf(payload) !== Object.prototype) {
    throw new TypeError('个人资料请求必须是普通对象')
  }
  const allowedFields = new Set(['nickName', 'realName', 'avatar', 'sex', 'birthday', 'email'])
  const fieldNames = Object.getOwnPropertyNames(payload)
  const descriptors = Object.getOwnPropertyDescriptors(payload)
  if (
    Object.getOwnPropertySymbols(payload).length > 0 ||
    fieldNames.some((field) => !allowedFields.has(field)) ||
    fieldNames.some((field) => !Object.prototype.hasOwnProperty.call(descriptors[field], 'value'))
  ) {
    throw new TypeError('个人资料请求包含未声明字段')
  }
  const normalized = {}
  for (const [field, limit] of [['nickName', 30], ['realName', 30]]) {
    if (!Object.prototype.hasOwnProperty.call(payload, field)) continue
    const value = normalizeOptionalAuthText(payload[field], field)
    if (!value) continue
    if (value.length > limit) throw new TypeError(`${field} 超出长度限制`)
    normalized[field] = value
  }
  if (Object.prototype.hasOwnProperty.call(payload, 'sex')) {
    const sex = normalizeOptionalAuthText(payload.sex, 'sex')
    if (sex) {
      if (!['0', '1', '2'].includes(sex)) throw new TypeError('sex 必须为 0、1 或 2')
      normalized.sex = sex
    }
  }
  if (Object.prototype.hasOwnProperty.call(payload, 'birthday')) {
    const value = normalizeOptionalAuthText(payload.birthday, 'birthday')
    if (value) {
      if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) {
        throw new TypeError('birthday 必须是 yyyy-MM-dd 日期')
      }
      normalized.birthday = value
    }
  }
  if (Object.prototype.hasOwnProperty.call(payload, 'email')) {
    const value = normalizeOptionalAuthText(payload.email, 'email')
    if (value) {
      if (value.length > 100 || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
        throw new TypeError('email 格式无效')
      }
      normalized.email = value
    }
  }
  if (Object.prototype.hasOwnProperty.call(payload, 'avatar')) {
    const value = payload.avatar
    if (value !== undefined && value !== null && value !== '') {
      if (!Number.isSafeInteger(value) || value <= 0) {
        throw new TypeError('avatar 必须是安全整数文件标识')
      }
      normalized.avatar = value
    }
  }
  if (Object.keys(normalized).length === 0) {
    throw new TypeError('个人资料至少需要一个可更新字段')
  }
  return normalized
}

const assertPlainPayload = (payload, allowedFields, label) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload) || Object.getPrototypeOf(payload) !== Object.prototype) {
    throw new TypeError(`${label}必须是普通对象`)
  }
  const fieldNames = Object.getOwnPropertyNames(payload)
  const descriptors = Object.getOwnPropertyDescriptors(payload)
  if (
    Object.getOwnPropertySymbols(payload).length > 0 ||
    fieldNames.some((field) => !allowedFields.has(field)) ||
    fieldNames.some((field) => !Object.prototype.hasOwnProperty.call(descriptors[field], 'value'))
  ) {
    throw new TypeError(`${label}包含未声明字段`)
  }
}

const normalizeUploadId = (value, field) => {
  if (typeof value !== 'string' || !value.trim()) throw new TypeError(`${field}必须是非空字符串`)
  return value.trim()
}

const normalizeUploadFileName = (value) => {
  if (typeof value !== 'string' || !value.trim()) throw new TypeError('fileName必须是非空字符串')
  return value.trim()
}

const normalizeUploadMd5 = (value, field) => {
  if (typeof value !== 'string' || !/^[a-f0-9]{32}$/i.test(value)) {
    throw new TypeError(`${field}必须是 32 位十六进制 MD5`)
  }
  return value.toLowerCase()
}

const normalizeUploadSize = (value, field) => {
  if (!Number.isSafeInteger(value) || value <= 0) throw new TypeError(`${field}必须是正安全整数`)
  return value
}

const normalizeResumableInitPayload = (payload) => {
  const allowedFields = new Set(['uploadId', 'fileName', 'fileMd5', 'totalSize', 'totalChunks', 'chunkSize', 'contentType'])
  assertPlainPayload(payload, allowedFields, '文件初始化请求')
  if (!Number.isInteger(payload.totalChunks) || payload.totalChunks <= 0 || payload.totalChunks > 2147483647) {
    throw new TypeError('totalChunks必须是正 int32')
  }
  const data = {
    uploadId: normalizeUploadId(payload.uploadId, 'uploadId'),
    fileName: normalizeUploadFileName(payload.fileName),
    fileMd5: normalizeUploadMd5(payload.fileMd5, 'fileMd5'),
    totalSize: normalizeUploadSize(payload.totalSize, 'totalSize'),
    totalChunks: payload.totalChunks,
    chunkSize: normalizeUploadSize(payload.chunkSize, 'chunkSize')
  }
  const contentType = normalizeOptionalAuthText(payload.contentType, 'contentType')
  if (contentType) data.contentType = contentType
  return data
}

const normalizeResumableCompletePayload = (payload) => {
  const allowedFields = new Set(['uploadId', 'fileName', 'fileMd5', 'totalSize', 'totalChunks'])
  assertPlainPayload(payload, allowedFields, '文件完成请求')
  if (!Number.isInteger(payload.totalChunks) || payload.totalChunks <= 0 || payload.totalChunks > 2147483647) {
    throw new TypeError('totalChunks必须是正 int32')
  }
  return {
    uploadId: normalizeUploadId(payload.uploadId, 'uploadId'),
    fileName: normalizeUploadFileName(payload.fileName),
    fileMd5: normalizeUploadMd5(payload.fileMd5, 'fileMd5'),
    totalSize: normalizeUploadSize(payload.totalSize, 'totalSize'),
    totalChunks: payload.totalChunks
  }
}

const normalizeUploadOssId = (value, field) => {
  const id = typeof value === 'number' && Number.isSafeInteger(value) ? String(value) : value
  if (typeof id !== 'string' || !/^[1-9]\d*$/.test(id)) {
    throw createRequestError(`文件服务字段 ${field} 无效`, 'FILE_RESPONSE_INVALID')
  }
  return id
}

const normalizeOssIdString = (value, field) => {
  if (typeof value !== 'string' || !/^[1-9]\d*$/.test(value)) {
    throw new TypeError(`${field} 必须是正整数 OSS ID 字符串`)
  }
  return value
}

const normalizeResumableInitResult = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
    throw createRequestError('文件初始化响应格式无效', 'FILE_RESPONSE_INVALID')
  }
  if (typeof payload.instant !== 'boolean') {
    throw createRequestError('文件初始化响应缺少 instant', 'FILE_RESPONSE_INVALID')
  }
  const ossId = payload.ossId === undefined || payload.ossId === null ? null : normalizeUploadOssId(payload.ossId, 'ossId')
  if (payload.instant && !ossId) {
    throw createRequestError('秒传响应缺少 ossId', 'FILE_RESPONSE_INVALID')
  }
  const uploadId = payload.instant && (payload.uploadId === undefined || payload.uploadId === null)
    ? null
    : normalizeUploadId(payload.uploadId, '响应 uploadId')
  return {
    uploadId,
    instant: payload.instant,
    ossId,
    url: normalizeProfileResponseText(payload.url, 'url'),
    fileName: normalizeProfileResponseText(payload.fileName, 'fileName')
  }
}

const normalizeResumableCompleteResult = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
    throw createRequestError('文件完成响应格式无效', 'FILE_RESPONSE_INVALID')
  }
  return {
    ossId: normalizeUploadOssId(payload.ossId, 'ossId'),
    url: normalizeProfileResponseText(payload.url, 'url'),
    thumbnailUrl: normalizeProfileResponseText(payload.thumbnailUrl, 'thumbnailUrl'),
    fileName: normalizeProfileResponseText(payload.fileName, 'fileName')
  }
}

const normalizeFeedbackPayload = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload) || Object.getPrototypeOf(payload) !== Object.prototype) {
    throw new TypeError('反馈请求必须是普通对象')
  }
  const allowedFields = new Set(['feedbackType', 'feedbackContent', 'contactInfo'])
  const fieldNames = Object.getOwnPropertyNames(payload)
  if (Object.getOwnPropertySymbols(payload).length > 0 || fieldNames.some((field) => !allowedFields.has(field))) {
    throw new TypeError('反馈请求包含未声明字段')
  }
  const descriptors = Object.getOwnPropertyDescriptors(payload)
  if (fieldNames.some((field) => !Object.prototype.hasOwnProperty.call(descriptors[field], 'value'))) {
    throw new TypeError('反馈字段必须是普通数据属性')
  }
  if (typeof payload.feedbackContent !== 'string' || !payload.feedbackContent.trim()) {
    throw new TypeError('反馈内容必须是非空字符串')
  }
  const normalized = { feedbackContent: payload.feedbackContent.trim() }
  for (const optionalField of ['feedbackType', 'contactInfo']) {
    if (!Object.prototype.hasOwnProperty.call(payload, optionalField)) continue
    if (typeof payload[optionalField] !== 'string') {
      throw new TypeError(`反馈字段 ${optionalField} 必须是字符串`)
    }
    const value = payload[optionalField].trim()
    if (value) {
      if (optionalField === 'feedbackType' && !['advice', 'bug', 'complaint', 'other'].includes(value)) {
        throw new TypeError('feedbackType 必须为 advice、bug、complaint 或 other')
      }
      normalized[optionalField] = value
    }
  }
  return normalized
}

const normalizeMyGenealogyId = (value) => {
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw createRequestError('我的家谱响应包含无效标识', 'GENEALOGY_RESPONSE_INVALID')
}

const normalizeGenealogyPathId = (value) => {
  const id = typeof value === 'number' && Number.isSafeInteger(value) ? String(value) : value
  if (typeof id !== 'string' || !/^[1-9]\d*$/.test(id)) {
    throw createRequestError('家谱标识无效', 'GENEALOGY_ID_INVALID')
  }
  return id
}

const normalizeOptionalGenealogyText = (value, label) => {
  if (value === undefined || value === null) return ''
  if (typeof value !== 'string') {
    throw createRequestError(`我的家谱响应字段 ${label} 无效`, 'GENEALOGY_RESPONSE_INVALID')
  }
  return value.trim()
}

const normalizeAppGenealogy = (item) => {
  if (!item || typeof item !== 'object' || Array.isArray(item)) {
    throw createRequestError('我的家谱响应包含无效条目', 'GENEALOGY_RESPONSE_INVALID')
  }
  const name = normalizeOptionalGenealogyText(item.genealogyName, 'genealogyName')
  if (!name) {
    throw createRequestError('我的家谱响应缺少家谱名称', 'GENEALOGY_RESPONSE_INVALID')
  }
  for (const field of ['canManage', 'canEditContent']) {
    if (typeof item[field] !== 'boolean') {
      throw createRequestError(`我的家谱响应字段 ${field} 无效`, 'GENEALOGY_RESPONSE_INVALID')
    }
  }
  if (item.canView === false) {
    throw createRequestError('当前账号无权查看该家谱', 'GENEALOGY_FORBIDDEN')
  }
  if (!Number.isSafeInteger(item.memberCount) || item.memberCount < 0) {
    throw createRequestError('我的家谱响应成员数量无效', 'GENEALOGY_RESPONSE_INVALID')
  }
  const personCount = item.personCount ?? null
  if (personCount !== null && (!Number.isSafeInteger(personCount) || personCount < 0)) {
    throw createRequestError('我的家谱响应世系人数无效', 'GENEALOGY_RESPONSE_INVALID')
  }
  return {
    id: normalizeMyGenealogyId(item.genealogyId),
    name,
    surname: normalizeOptionalGenealogyText(item.surname, 'surname'),
    hall: normalizeOptionalGenealogyText(item.ancestralHall, 'ancestralHall'),
    location:
      normalizeOptionalGenealogyText(item.regionFullName, 'regionFullName') ||
      normalizeOptionalGenealogyText(item.regionName, 'regionName') ||
      normalizeOptionalGenealogyText(item.originPlace, 'originPlace') ||
      normalizeOptionalGenealogyText(item.addressDetail, 'addressDetail') ||
      '地区待补',
    memberCount: item.memberCount,
    personCount,
    accessPreset: fromApiGenealogyAccess({
      visibility: normalizeOptionalGenealogyText(item.visibility, 'visibility'),
      joinMode: normalizeOptionalGenealogyText(item.joinMode, 'joinMode')
    }),
    accessRole: item.canManage ? 'owner' : 'member',
    canManage: item.canManage,
    canEditContent: item.canEditContent,
    intro: normalizeOptionalGenealogyText(item.intro, 'intro'),
    joinTime: normalizeOptionalGenealogyText(item.joinTime, 'joinTime')
  }
}

const normalizeMyGenealogies = (value) => {
  if (!Array.isArray(value)) {
    throw createRequestError('我的家谱响应不是列表', 'GENEALOGY_RESPONSE_INVALID')
  }
  const normalized = value.map((item) => {
    const genealogy = normalizeAppGenealogy(item)
    return {
      id: genealogy.id,
      name: genealogy.name,
      surname: genealogy.surname,
      hall: genealogy.hall,
      location: genealogy.location,
      memberCount: genealogy.memberCount,
      accessRole: genealogy.accessRole,
      canManage: genealogy.canManage,
      canEditContent: genealogy.canEditContent
    }
  })
  if (new Set(normalized.map((item) => item.id)).size !== normalized.length) {
    throw createRequestError('我的家谱响应包含重复标识', 'GENEALOGY_RESPONSE_INVALID')
  }
  return normalized
}

const isPlainDataObject = (value) =>
  value !== null &&
  typeof value === 'object' &&
  !Array.isArray(value) &&
  Object.getPrototypeOf(value) === Object.prototype

const normalizeGenealogyCreateText = (value, field, { required = false } = {}) => {
  if (value === undefined || value === null) {
    if (required) throw new TypeError(`创建家谱缺少 ${field}`)
    return ''
  }
  if (typeof value !== 'string') throw new TypeError(`创建家谱字段 ${field} 必须是字符串`)
  const normalized = value.trim()
  if (required && !normalized) throw new TypeError(`创建家谱缺少 ${field}`)
  return normalized
}

const normalizeGenealogyCreatePayload = (payload) => {
  if (!isPlainDataObject(payload)) throw new TypeError('创建家谱请求必须是普通对象')
  const allowedFields = new Set([
    'genealogyName',
    'surname',
    'regionCode',
    'ancestralHall',
    'originPlace',
    'addressDetail',
    'intro',
    'coverOssId',
    'visibility',
    'joinMode'
  ])
  if (
    Object.getOwnPropertySymbols(payload).length > 0 ||
    Object.getOwnPropertyNames(payload).some((field) => !allowedFields.has(field))
  ) {
    throw new TypeError('创建家谱请求包含未声明字段')
  }

  const normalized = {
    genealogyName: normalizeGenealogyCreateText(payload.genealogyName, '谱名', { required: true }),
    surname: normalizeGenealogyCreateText(payload.surname, '姓氏', { required: true }),
    regionCode: normalizeGenealogyCreateText(payload.regionCode, '地区代码', { required: true })
  }
  for (const field of ['ancestralHall', 'originPlace', 'addressDetail', 'intro', 'visibility', 'joinMode']) {
    const value = normalizeGenealogyCreateText(payload[field], field)
    if (value) normalized[field] = value
  }
  if (payload.coverOssId !== undefined && payload.coverOssId !== null && payload.coverOssId !== '') {
    normalized.coverOssId = normalizeOssIdString(payload.coverOssId, '创建家谱字段 coverOssId')
  }
  return normalized
}

const normalizeGenealogyUpdatePayload = (payload) => {
  if (!isPlainDataObject(payload)) throw new TypeError('更新家谱请求必须是普通对象')
  const allowedFields = new Set([
    'genealogyName',
    'surname',
    'regionCode',
    'ancestralHall',
    'originPlace',
    'addressDetail',
    'intro',
    'coverOssId',
    'visibility',
    'joinMode'
  ])
  if (
    Object.getOwnPropertySymbols(payload).length > 0 ||
    Object.getOwnPropertyNames(payload).some((field) => !allowedFields.has(field))
  ) {
    throw new TypeError('更新家谱请求包含未声明字段')
  }

  const normalized = {}
  for (const field of [
    'genealogyName',
    'surname',
    'regionCode',
    'ancestralHall',
    'originPlace',
    'addressDetail',
    'intro',
    'visibility',
    'joinMode'
  ]) {
    if (!Object.prototype.hasOwnProperty.call(payload, field)) continue
    const value = normalizeGenealogyCreateText(payload[field], field)
    if (value) normalized[field] = value
  }
  if (Object.prototype.hasOwnProperty.call(payload, 'coverOssId') && payload.coverOssId !== null && payload.coverOssId !== '') {
    normalized.coverOssId = normalizeOssIdString(payload.coverOssId, '更新家谱字段 coverOssId')
  }
  if (!Object.keys(normalized).length) throw new TypeError('请至少填写一项需要更新的家谱信息')
  return normalized
}

const normalizeOptionalNonnegativeInteger = (value, label, code) => {
  if (value === undefined || value === null) return 0
  if (!Number.isSafeInteger(value) || value < 0) {
    throw createRequestError(`${label}无效`, code)
  }
  return value
}

const normalizeGenealogyQuota = (value) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('家谱配额响应无效', 'GENEALOGY_QUOTA_RESPONSE_INVALID')
  }
  const normalizeUsage = (field) => {
    if (!Number.isSafeInteger(value[field]) || value[field] < 0) {
      throw createRequestError(`家谱配额字段 ${field} 无效`, 'GENEALOGY_QUOTA_RESPONSE_INVALID')
    }
    return value[field]
  }
  const normalizeLimit = (field) => {
    if (!Number.isSafeInteger(value[field]) || value[field] < -1) {
      throw createRequestError(`家谱配额字段 ${field} 无效`, 'GENEALOGY_QUOTA_RESPONSE_INVALID')
    }
    return value[field]
  }
  const normalizePermission = (field) => {
    if (typeof value[field] !== 'boolean') {
      throw createRequestError(`家谱配额字段 ${field} 无效`, 'GENEALOGY_QUOTA_RESPONSE_INVALID')
    }
    return value[field]
  }
  return {
    createUsed: normalizeUsage('createUsed'),
    createLimit: normalizeLimit('createLimit'),
    createRemaining: normalizeLimit('createRemaining'),
    canCreate: normalizePermission('canCreate'),
    joinUsed: normalizeUsage('joinUsed'),
    joinLimit: normalizeLimit('joinLimit'),
    joinRemaining: normalizeLimit('joinRemaining'),
    canJoin: normalizePermission('canJoin')
  }
}

const normalizeOptionalNumericId = (value, label, code) => {
  if (value === undefined || value === null || value === '') return null
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw createRequestError(`${label}无效`, code)
}

const normalizeGenealogySettings = (value, expectedGenealogyId) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('家谱设置响应无效', 'GENEALOGY_SETTINGS_RESPONSE_INVALID')
  }
  const id = normalizeMyGenealogyId(value.genealogyId)
  if (id !== expectedGenealogyId) {
    throw createRequestError('家谱设置响应标识不匹配', 'GENEALOGY_SETTINGS_RESPONSE_INVALID')
  }
  const genealogyName = normalizeOptionalGenealogyText(value.genealogyName, 'genealogyName')
  const surname = normalizeOptionalGenealogyText(value.surname, 'surname')
  const regionCode = normalizeOptionalGenealogyText(value.regionCode, 'regionCode')
  if (!genealogyName || !surname || !regionCode) {
    throw createRequestError('家谱设置响应缺少名称、姓氏或地区', 'GENEALOGY_SETTINGS_RESPONSE_INVALID')
  }
  return {
    id,
    genealogyName,
    surname,
    ancestralHall: normalizeOptionalGenealogyText(value.ancestralHall, 'ancestralHall'),
    originPlace: normalizeOptionalGenealogyText(value.originPlace, 'originPlace'),
    regionCode,
    regionName: normalizeOptionalGenealogyText(value.regionName, 'regionName'),
    regionFullName: normalizeOptionalGenealogyText(value.regionFullName, 'regionFullName'),
    addressDetail: normalizeOptionalGenealogyText(value.addressDetail, 'addressDetail'),
    coverOssId: normalizeOptionalNumericId(value.coverOssId, 'coverOssId', 'GENEALOGY_SETTINGS_RESPONSE_INVALID'),
    intro: normalizeOptionalGenealogyText(value.intro, 'intro'),
    accessPreset: fromApiGenealogyAccess({
      visibility: normalizeOptionalGenealogyText(value.visibility, 'visibility'),
      joinMode: normalizeOptionalGenealogyText(value.joinMode, 'joinMode')
    }),
    visibility: normalizeOptionalGenealogyText(value.visibility, 'visibility'),
    joinMode: normalizeOptionalGenealogyText(value.joinMode, 'joinMode'),
    memberCount: normalizeOptionalNonnegativeInteger(value.memberCount, '家谱成员数量', 'GENEALOGY_SETTINGS_RESPONSE_INVALID'),
    personCount: normalizeOptionalNonnegativeInteger(value.personCount, '家谱人物数量', 'GENEALOGY_SETTINGS_RESPONSE_INVALID'),
    canManage: value.canManage === true,
    canEditContent: value.canEditContent === true
  }
}

const normalizeRegionParentCode = (value) => {
  if (value === undefined || value === null || value === '') return '0'
  if (typeof value !== 'string' || !value.trim()) throw new TypeError('地区父级标识无效')
  return value.trim()
}

const normalizeRegionCode = (value) => {
  if (typeof value !== 'string' || !value.trim()) throw new TypeError('行政区划编码无效')
  return value.trim()
}

const normalizeRegionSearchPayload = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
    throw new TypeError('行政区划搜索参数无效')
  }
  const keyword = typeof payload.keyword === 'string' ? payload.keyword.trim() : ''
  if (!keyword) throw new TypeError('行政区划搜索关键词无效')
  const data = { keyword }
  if (payload.level !== undefined && payload.level !== null && payload.level !== '') {
    if (!Number.isInteger(payload.level) || payload.level < 1 || payload.level > 5) {
      throw new TypeError('行政区划级别无效')
    }
    data.level = payload.level
  }
  if (payload.limit !== undefined && payload.limit !== null && payload.limit !== '') {
    if (!Number.isInteger(payload.limit)) throw new TypeError('行政区划搜索数量上限无效')
    data.limit = payload.limit
  }
  return data
}

const normalizeRegionSelectorItems = (value) => {
  if (!Array.isArray(value)) {
    throw createRequestError('地区选择响应不是列表', 'REGION_RESPONSE_INVALID')
  }
  return value.map((item) => {
    if (!item || typeof item !== 'object' || Array.isArray(item)) {
      throw createRequestError('地区选择响应包含无效条目', 'REGION_RESPONSE_INVALID')
    }
    const regionCode = normalizeOptionalGenealogyText(item.regionCode ?? item.value, 'regionCode')
    const label = normalizeOptionalGenealogyText(item.label ?? item.regionName, 'label')
    if (!regionCode || !label) {
      throw createRequestError('地区选择响应缺少地区名称或标识', 'REGION_RESPONSE_INVALID')
    }
    return {
      regionCode,
      label,
      parentCode: normalizeOptionalGenealogyText(item.parentCode, 'parentCode'),
      leaf: item.leaf === true,
      regionLevel: Number.isInteger(item.regionLevel) ? item.regionLevel : null
    }
  })
}

const normalizeCreatedGenealogy = (value) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('创建家谱响应无效', 'GENEALOGY_RESPONSE_INVALID')
  }
  const id = value.genealogyId
  if (typeof id === 'string' && /^[1-9]\d*$/.test(id)) return { id }
  if (typeof id === 'number' && Number.isSafeInteger(id) && id > 0) return { id: String(id) }
  throw createRequestError('创建家谱响应缺少有效标识', 'GENEALOGY_RESPONSE_INVALID')
}

const saveLogin = (loginResult) => {
  const token = loginResult?.access_token
  if (!token) throw new Error('登录响应未包含会话令牌')
  session.saveToken(token)
  return loginResult
}

const lineageTreeError = (message) =>
  createRequestError(message, 'LINEAGE_TREE_RESPONSE_INVALID')

const normalizeLineagePersonId = (value) => {
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw lineageTreeError('世系树包含无效人物标识')
}

const normalizeLineageText = (value, label, { required = false } = {}) => {
  if (value === undefined || value === null) {
    if (required) throw lineageTreeError(`世系树缺少${label}`)
    return ''
  }
  if (typeof value !== 'string') throw lineageTreeError(`世系树${label}无效`)
  const normalized = value.trim()
  if (required && !normalized) throw lineageTreeError(`世系树缺少${label}`)
  return normalized
}

const lineageDatePart = (value, label) => {
  const normalized = normalizeLineageText(value, label)
  if (!normalized) return ''
  if (!/^\d{4}-\d{2}-\d{2}/.test(normalized)) {
    throw lineageTreeError(`世系树${label}无效`)
  }
  if (normalized.length === 10) return normalized
  const instant = new Date(normalized)
  if (Number.isNaN(instant.getTime())) throw lineageTreeError(`世系树${label}无效`)

  const chinaTime = new Date(instant.getTime() + 8 * 60 * 60 * 1000)
  const year = chinaTime.getUTCFullYear()
  const month = String(chinaTime.getUTCMonth() + 1).padStart(2, '0')
  const day = String(chinaTime.getUTCDate()).padStart(2, '0')
  return `${year}-${month}-${day}`
}

const normalizeLineageTree = (value) => {
  if (!Array.isArray(value)) throw lineageTreeError('世系树响应不是列表')
  const seen = new Set()
  const normalized = []
  const normalizedById = new Map()
  const appendNode = (node, parentId, relationOverride = '', spouseOf = '') => {
    if (!node || typeof node !== 'object' || Array.isArray(node)) {
      throw lineageTreeError('世系树包含无效节点')
    }
    const id = normalizeLineagePersonId(node.personId)
    if (seen.has(id)) throw lineageTreeError('世系树包含重复人物标识')
    seen.add(id)
    if (seen.size > 5000) throw lineageTreeError('世系树节点数量超出客户端上限')
    if (!Number.isSafeInteger(node.generation) || node.generation < 1) {
      throw lineageTreeError('世系树人物世代无效')
    }
    const generationName = normalizeLineageText(node.generationName, '字辈')
    const relationName = normalizeLineageText(node.relationName, '人物关系')
    const birthDate = lineageDatePart(node.birthDate, '出生日期')
    const deathDate = lineageDatePart(node.deathDate, '逝世日期')
    const normalizedNode = {
      id,
      parentId,
      ...(spouseOf ? { spouseOf } : {}),
      name: normalizeLineageText(node.name, '人物姓名', { required: true }),
      relation:
        relationOverride ||
        (parentId
          ? (relationName && relationName !== '配偶' ? relationName : '后代')
          : relationName || '始祖'),
      generation: node.generation,
      branch: generationName
        ? (generationName.endsWith('字辈') ? generationName : `${generationName}字辈`)
        : '字辈待补',
      years:
        birthDate || deathDate
          ? `${birthDate}—${deathDate}`
          : '生卒待补',
      sex: normalizeLineageText(node.sex, '性别'),
      personStatus: normalizeLineageText(node.personStatus, '人物状态')
    }
    normalized.push(normalizedNode)
    normalizedById.set(id, normalizedNode)
    return id
  }
  const walk = (node, parentId = null, depth = 0) => {
    if (depth > 64) throw lineageTreeError('世系树深度超出客户端上限')
    if (!node || typeof node !== 'object' || Array.isArray(node)) {
      throw lineageTreeError('世系树包含无效节点')
    }
    const spouses = node.spouses ?? []
    const children = node.children ?? []
    if (!Array.isArray(spouses) || !Array.isArray(children)) {
      throw lineageTreeError('世系树亲属集合无效')
    }
    const id = normalizeLineagePersonId(node.personId)
    const knownSpouseId = spouses
      .map((spouse) => normalizeLineagePersonId(spouse?.personId))
      .find((spouseId) => normalizedById.has(spouseId)) || ''
    if (seen.has(id)) {
      if (knownSpouseId) return id
      throw lineageTreeError('世系树包含重复人物标识')
    }
    const knownSpouse = knownSpouseId ? normalizedById.get(knownSpouseId) : null
    const nodeParentId = knownSpouse ? knownSpouse.parentId : parentId
    const appendedId = appendNode(node, nodeParentId, knownSpouse ? '配偶' : '', knownSpouseId)
    spouses.forEach((spouse) => {
      const spouseId = normalizeLineagePersonId(spouse?.personId)
      if (seen.has(spouseId)) return
      appendNode(spouse, nodeParentId, '配偶', appendedId)
    })
    children.forEach((child) => walk(child, knownSpouseId || appendedId, depth + 1))
  }
  value.forEach((root) => walk(root))
  return normalized
}

const lineagePersonError = (message) =>
  createRequestError(message, 'LINEAGE_PERSON_RESPONSE_INVALID')

const normalizeLineagePersonIdentity = (value, label) => {
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw lineagePersonError(`成员详情${label}无效`)
}

const normalizeOptionalLineagePersonIdentity = (value, label) => {
  if (value === undefined || value === null || value === '') return ''
  return normalizeLineagePersonIdentity(value, label)
}

const normalizeLineagePersonText = (value, label, { required = false } = {}) => {
  if (value === undefined || value === null) {
    if (required) throw lineagePersonError(`成员详情缺少${label}`)
    return ''
  }
  if (typeof value !== 'string') throw lineagePersonError(`成员详情${label}无效`)
  const normalized = value.trim()
  if (required && !normalized) throw lineagePersonError(`成员详情缺少${label}`)
  return normalized
}

const normalizeLineagePersonDate = (value, label) => {
  const normalized = normalizeLineagePersonText(value, label)
  if (!normalized) return ''
  if (!/^\d{4}-\d{2}-\d{2}(?:[T\s].*)?$/.test(normalized)) {
    throw lineagePersonError(`成员详情${label}无效`)
  }
  const datePart = normalized.slice(0, 10)
  const parsed = new Date(`${datePart}T00:00:00Z`)
  if (
    Number.isNaN(parsed.getTime()) ||
    parsed.toISOString().slice(0, 10) !== datePart
  ) {
    throw lineagePersonError(`成员详情${label}无效`)
  }
  return datePart
}

const normalizeLineagePersonDetail = (
  value,
  expectedGenealogyId,
  expectedPersonId,
) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw lineagePersonError('成员详情响应不是对象')
  }
  const genealogyId = normalizeLineagePersonIdentity(value.genealogyId, '家谱标识')
  const id = normalizeLineagePersonIdentity(value.personId, '人物标识')
  if (genealogyId !== expectedGenealogyId || id !== expectedPersonId) {
    throw lineagePersonError('成员详情响应标识与请求不匹配')
  }
  if (!Number.isSafeInteger(value.generation) || value.generation < 1) {
    throw lineagePersonError('成员详情世代无效')
  }
  const name = normalizeLineagePersonText(value.name, '姓名', { required: true })
  const appUserId = normalizeOptionalLineagePersonIdentity(value.appUserId, '绑定用户标识')
  const bindingMode = value.bindingMode === undefined || value.bindingMode === null || value.bindingMode === ''
    ? (appUserId ? 'SPECIFIED' : 'NONE')
    : normalizeLineagePersonText(value.bindingMode, '身份认领方式')
  if (!['NONE', 'SELF', 'SPECIFIED'].includes(bindingMode)) {
    throw lineagePersonError('成员详情身份认领方式无效')
  }
  const personNo = normalizeLineagePersonText(value.personNo, '人物编号')
  const generationName = normalizeLineagePersonText(value.generationName, '字辈')
  const aliasName = normalizeLineagePersonText(value.aliasName, '别名或曾用名')
  const avatarOssId = normalizeOptionalLineagePersonIdentity(value.avatarOssId, '头像文件标识')
  const birthDate = normalizeLineagePersonDate(value.birthDate, '出生日期')
  const deathDate = normalizeLineagePersonDate(value.deathDate, '逝世日期')
  const birthLunar = normalizeLineagePersonText(value.birthLunar, '出生农历')
  const deathLunar = normalizeLineagePersonText(value.deathLunar, '逝世农历')
  const birthPlace = normalizeLineagePersonText(value.birthPlace, '出生地')
  const deathPlace = normalizeLineagePersonText(value.deathPlace, '逝世地')
  const burialPlace = normalizeLineagePersonText(value.burialPlace, '安葬地')
  const spouseNames = normalizeLineagePersonText(value.spouseNames, '配偶姓名')
  const personStatus = normalizeLineagePersonText(value.personStatus, '人物状态')
  const biography = normalizeLineagePersonText(value.biography, '生平')
  const remark = normalizeLineagePersonText(value.remark, '备注')
  const relationName = normalizeLineagePersonText(value.relationName, '关系显示名称')
  const sortOrder = value.sortOrder === undefined || value.sortOrder === null
    ? null
    : normalizeOptionalSafeInteger(value.sortOrder, '人物排序值')
  const relatives = []
  for (const relation of [
    { id: value.fatherId, name: value.fatherName, label: '父亲' },
    { id: value.motherId, name: value.motherName, label: '母亲' }
  ]) {
    if (relation.id === undefined || relation.id === null) continue
    const relativeId = normalizeLineagePersonIdentity(relation.id, `${relation.label}标识`)
    if (relativeId === id || relatives.some((item) => item.id === relativeId)) {
      throw lineagePersonError('成员详情亲属标识冲突')
    }
    relatives.push({
      id: relativeId,
      name: normalizeLineagePersonText(relation.name, `${relation.label}姓名`) || relation.label,
      relation: relation.label
    })
  }
  return {
    id,
    genealogyId,
    genealogyName: normalizeLineagePersonText(value.genealogyName, '家谱名称') || '当前家谱',
    name,
    appUserId,
    bindingMode,
    personNo,
    aliasName,
    generation: value.generation,
    generationName,
    avatarOssId,
    relation: value.generation === 1 ? '始祖' : '家谱成员',
    branch: generationName
      ? (generationName.endsWith('字辈') ? generationName : `${generationName}字辈`)
      : '字辈待补',
    sex: normalizeLineagePersonText(value.sex, '性别'),
    birthDate,
    birthLunar,
    deathDate,
    deathLunar,
    years: birthDate || deathDate ? `${birthDate}—${deathDate}` : '生卒待补',
    birthplace: birthPlace,
    deathPlace,
    burialPlace,
    spouseNames,
    personStatus,
    biography,
    remark,
    relationName,
    sortOrder,
    status: ['DECEASED', 'DEAD'].includes(personStatus.toUpperCase()) ? 'deceased' : 'normal',
    relatives
  }
}

const normalizeLineagePersonPage = (value, expectedGenealogyId) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw lineagePersonError('成员分页响应不是对象')
  }
  if (!Array.isArray(value.rows)) {
    throw lineagePersonError('成员分页缺少 rows')
  }
  if (!Number.isSafeInteger(value.total) || value.total < 0) {
    throw lineagePersonError('成员分页 total 无效')
  }
  const rows = value.rows.map((item) =>
    normalizeLineagePersonDetail(
      item,
      expectedGenealogyId,
      normalizeLineagePersonIdentity(item?.personId, '人物标识'),
    ),
  )
  if (new Set(rows.map((item) => item.id)).size !== rows.length) {
    throw lineagePersonError('成员分页包含重复人物标识')
  }
  return { rows, total: value.total }
}

const normalizeFeedCommentId = (value, label) => {
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw createRequestError(`家族动态评论${label}无效`, 'FEED_COMMENT_RESPONSE_INVALID')
}

const normalizeFeedCommentText = (value, label, { required = false } = {}) => {
  if (value === undefined || value === null) {
    if (required) throw createRequestError(`家族动态评论缺少${label}`, 'FEED_COMMENT_RESPONSE_INVALID')
    return ''
  }
  if (typeof value !== 'string') {
    throw createRequestError(`家族动态评论${label}无效`, 'FEED_COMMENT_RESPONSE_INVALID')
  }
  const normalized = value.trim()
  if (required && !normalized) {
    throw createRequestError(`家族动态评论缺少${label}`, 'FEED_COMMENT_RESPONSE_INVALID')
  }
  return normalized
}

const normalizeFeedComments = (value, expectedGenealogyId, expectedFeedId) => {
  if (!Array.isArray(value)) {
    throw createRequestError('家族动态评论响应不是列表', 'FEED_COMMENT_RESPONSE_INVALID')
  }
  const comments = value.map((item) => {
    if (!item || typeof item !== 'object' || Array.isArray(item)) {
      throw createRequestError('家族动态评论包含无效条目', 'FEED_COMMENT_RESPONSE_INVALID')
    }
    const genealogyId = normalizeFeedCommentId(item.genealogyId, '家谱标识')
    const feedId = normalizeFeedCommentId(item.feedId, '动态标识')
    if (genealogyId !== expectedGenealogyId || feedId !== expectedFeedId) {
      throw createRequestError('家族动态评论归属与请求不匹配', 'FEED_COMMENT_RESPONSE_INVALID')
    }
    return {
      id: normalizeFeedCommentId(item.commentId, '标识'),
      author: normalizeFeedCommentText(item.appUserNickName, '用户昵称') || '未署名成员',
      content: normalizeFeedCommentText(item.commentContent, '评论内容', { required: true }),
      time: normalizeFeedCommentText(item.createTime, '创建时间'),
      parentCommentId: item.parentCommentId === undefined || item.parentCommentId === null
        ? null
        : normalizeFeedCommentId(item.parentCommentId, '父评论标识'),
      replyCount: Number.isSafeInteger(item.replyCount) && item.replyCount >= 0 ? item.replyCount : 0,
    }
  })
  if (new Set(comments.map((item) => item.id)).size !== comments.length) {
    throw createRequestError('家族动态评论包含重复标识', 'FEED_COMMENT_RESPONSE_INVALID')
  }
  return comments
}

const normalizeFeedCommentPayload = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload) || Object.getPrototypeOf(payload) !== Object.prototype) {
    throw new TypeError('家族动态评论请求必须是普通对象')
  }
  const fields = Object.keys(payload)
  if (fields.some((field) => !['parentCommentId', 'commentContent'].includes(field))) {
    throw new TypeError('家族动态评论请求包含未声明字段')
  }
  const commentContent = normalizeFeedCommentText(payload.commentContent, '评论内容', { required: true })
  if (Array.from(commentContent).length > 1000) throw new TypeError('家族动态评论不能超过 1000 个字符')
  const data = { commentContent }
  if (payload.parentCommentId !== undefined && payload.parentCommentId !== null) {
    data.parentCommentId = normalizeFeedCommentId(payload.parentCommentId, '父评论标识')
  }
  return data
}

const normalizeFeedCreatePayload = (payload) => {
  const allowedFields = new Set(['feedType', 'feedContent', 'mediaOssIds', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '家族动态请求')
  if (typeof payload.feedContent !== 'string' || !payload.feedContent.trim()) {
    throw new TypeError('家族动态内容不能为空')
  }
  const data = { feedContent: payload.feedContent.trim() }
  for (const field of ['feedType', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  const mediaOssIds = normalizeOptionalOssIdList(payload.mediaOssIds)
  if (mediaOssIds) data.mediaOssIds = mediaOssIds
  if (payload.sortOrder !== undefined && payload.sortOrder !== null && payload.sortOrder !== '') {
    const sortOrder = typeof payload.sortOrder === 'number' ? payload.sortOrder : Number(payload.sortOrder)
    if (!Number.isSafeInteger(sortOrder)) throw new TypeError('sortOrder 必须是安全整数')
    data.sortOrder = sortOrder
  }
  return data
}

const normalizeFamilyFeedRows = (value, expectedGenealogyId) => {
  if (!Array.isArray(value)) {
    throw createRequestError('家族动态响应不是列表', 'FEED_RESPONSE_INVALID')
  }
  const rows = value.map((item) => {
    if (!item || typeof item !== 'object' || Array.isArray(item)) {
      throw createRequestError('家族动态响应包含无效条目', 'FEED_RESPONSE_INVALID')
    }
    const genealogyId = normalizeOptionalNumericId(item.genealogyId, '动态家谱标识', 'FEED_RESPONSE_INVALID')
    if (genealogyId && genealogyId !== expectedGenealogyId) {
      throw createRequestError('家族动态归属与请求不匹配', 'FEED_RESPONSE_INVALID')
    }
    const id = normalizeOptionalNumericId(item.feedId, '动态标识', 'FEED_RESPONSE_INVALID')
    const content = normalizeOptionalGenealogyText(item.feedContent, 'feedContent')
    if (!id || !content) {
      throw createRequestError('家族动态响应缺少标识或内容', 'FEED_RESPONSE_INVALID')
    }
    return {
      id,
      genealogyId: expectedGenealogyId,
      content,
      publisher: normalizeOptionalGenealogyText(item.publisherNickName, 'publisherNickName') || '家族成员',
      type: normalizeOptionalGenealogyText(item.feedType, 'feedType') || '文字动态',
      time: normalizeOptionalGenealogyText(item.createTime, 'createTime'),
      mediaOssIds: normalizeOptionalGenealogyText(item.mediaOssIds, 'mediaOssIds'),
      likeCount: normalizeOptionalNonnegativeInteger(item.likeCount, '动态点赞数', 'FEED_RESPONSE_INVALID'),
      commentCount: normalizeOptionalNonnegativeInteger(item.commentCount, '动态评论数', 'FEED_RESPONSE_INVALID'),
      likedByMe: typeof item.likedByMe === 'boolean' ? item.likedByMe : null,
      pinned: normalizeOptionalGenealogyText(item.pinned, 'pinned')
    }
  })
  if (new Set(rows.map((item) => item.id)).size !== rows.length) {
    throw createRequestError('家族动态响应包含重复标识', 'FEED_RESPONSE_INVALID')
  }
  return rows
}

const normalizeFamilyFeed = (value, expectedGenealogyId, expectedFeedId) => {
  const [feed] = normalizeFamilyFeedRows([value], expectedGenealogyId)
  if (feed.id !== expectedFeedId) {
    throw createRequestError('动态详情响应标识不匹配', 'FEED_RESPONSE_INVALID')
  }
  return feed
}

const normalizeFamilyArticleRows = (value, expectedGenealogyId) => {
  if (!Array.isArray(value)) {
    throw createRequestError('谱文响应不是列表', 'ARTICLE_RESPONSE_INVALID')
  }
  const rows = value.map((item) => {
    if (!item || typeof item !== 'object' || Array.isArray(item)) {
      throw createRequestError('谱文响应包含无效条目', 'ARTICLE_RESPONSE_INVALID')
    }
    const genealogyId = normalizeOptionalNumericId(item.genealogyId, '谱文家谱标识', 'ARTICLE_RESPONSE_INVALID')
    if (genealogyId && genealogyId !== expectedGenealogyId) {
      throw createRequestError('谱文归属与请求不匹配', 'ARTICLE_RESPONSE_INVALID')
    }
    const id = normalizeOptionalNumericId(item.articleId ?? item.id, '谱文标识', 'ARTICLE_RESPONSE_INVALID')
    const title = normalizeOptionalGenealogyText(item.articleTitle ?? item.title, 'articleTitle')
    const content = normalizeOptionalGenealogyText(item.articleContent, 'articleContent')
    if (!id || !title) {
      throw createRequestError('谱文响应缺少标识或标题', 'ARTICLE_RESPONSE_INVALID')
    }
    return {
      id,
      genealogyId: expectedGenealogyId,
      title,
      summary: normalizeOptionalGenealogyText(item.articleSummary ?? item.summary, 'articleSummary'),
      content,
      author: normalizeOptionalGenealogyText(item.authorName ?? item.author, 'authorName') || '家族成员',
      time: normalizeOptionalGenealogyText(item.publishTime ?? item.updatedAt, 'publishTime'),
      category: normalizeOptionalGenealogyText(item.categoryName ?? item.category, 'categoryName'),
      coverOssId: normalizeOptionalNumericId(item.coverOssId, 'coverOssId', 'ARTICLE_RESPONSE_INVALID'),
      viewCount: normalizeOptionalNonnegativeInteger(item.viewCount, '谱文阅读数', 'ARTICLE_RESPONSE_INVALID')
    }
  })
  if (new Set(rows.map((item) => item.id)).size !== rows.length) {
    throw createRequestError('谱文响应包含重复标识', 'ARTICLE_RESPONSE_INVALID')
  }
  return rows
}

const normalizeFamilyArticle = (value, expectedGenealogyId, expectedArticleId) => {
  const [article] = normalizeFamilyArticleRows([value], expectedGenealogyId)
  if (article.id !== expectedArticleId) {
    throw createRequestError('谱文详情响应标识不匹配', 'ARTICLE_RESPONSE_INVALID')
  }
  return article
}

const normalizeArticleCreatePayload = (payload) => {
  const allowedFields = new Set([
    'categoryId',
    'articleTitle',
    'articleSummary',
    'coverOssId',
    'articleContent',
    'authorName',
    'sortOrder',
    'status'
  ])
  assertPlainPayload(payload, allowedFields, '谱文请求')
  const articleTitle = typeof payload.articleTitle === 'string' ? payload.articleTitle.trim() : ''
  const articleContent = typeof payload.articleContent === 'string' ? payload.articleContent.trim() : ''
  if (!articleTitle) throw new TypeError('谱文标题不能为空')
  if (!articleContent) throw new TypeError('谱文正文不能为空')
  const data = { articleTitle, articleContent }
  for (const field of ['articleSummary', 'authorName', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  for (const field of ['categoryId', 'sortOrder']) {
    if (payload[field] === undefined || payload[field] === null || payload[field] === '') continue
    const value = typeof payload[field] === 'number' ? payload[field] : Number(payload[field])
    if (!Number.isSafeInteger(value)) throw new TypeError(`${field} 必须是安全整数`)
    data[field] = value
  }
  if (payload.coverOssId !== undefined && payload.coverOssId !== null && payload.coverOssId !== '') {
    data.coverOssId = normalizeOssIdString(payload.coverOssId, 'coverOssId')
  }
  return data
}

const normalizeAlbumCreatePayload = (payload) => {
  const allowedFields = new Set(['albumName', 'albumDesc', 'coverOssId', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '相册请求')
  if (typeof payload.albumName !== 'string' || !payload.albumName.trim()) {
    throw new TypeError('相册名称不能为空')
  }
  const data = { albumName: payload.albumName.trim() }
  for (const field of ['albumDesc', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  if (payload.coverOssId !== undefined && payload.coverOssId !== null && payload.coverOssId !== '') {
    data.coverOssId = normalizeOssIdString(payload.coverOssId, 'coverOssId')
  }
  for (const field of ['sortOrder']) {
    if (payload[field] === undefined || payload[field] === null || payload[field] === '') continue
    const value = typeof payload[field] === 'number' ? payload[field] : Number(payload[field])
    if (!Number.isSafeInteger(value)) throw new TypeError(`${field} 必须是安全整数`)
    data[field] = value
  }
  return data
}

const normalizeAlbumPhotoCreatePayload = (payload) => {
  const allowedFields = new Set(['ossId', 'photoTitle', 'photoDesc', 'photographer', 'shootTime', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '相册照片请求')
  const ossId = normalizeOssIdString(payload.ossId, '相册照片 ossId')
  const data = { ossId }
  for (const field of ['photoTitle', 'photoDesc', 'photographer', 'shootTime', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  const sortOrder = normalizeOptionalSafeInteger(payload.sortOrder, 'sortOrder')
  if (sortOrder !== undefined) data.sortOrder = sortOrder
  return data
}

const normalizeVideoPayload = (payload) => {
  const allowedFields = new Set(['videoTitle', 'videoDesc', 'coverOssId', 'videoOssId', 'durationSeconds', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '视频请求')
  const videoTitle = normalizeOptionalAuthText(payload.videoTitle, '视频标题')
  if (!videoTitle) throw new TypeError('视频标题不能为空')
  const videoOssId = normalizeOssIdString(payload.videoOssId, '视频文件 OSS ID')
  const data = { videoTitle, videoOssId }
  const videoDesc = normalizeOptionalAuthText(payload.videoDesc, '视频说明')
  if (videoDesc) data.videoDesc = videoDesc
  if (payload.coverOssId !== undefined && payload.coverOssId !== null && payload.coverOssId !== '') {
    data.coverOssId = normalizeOssIdString(payload.coverOssId, '视频封面 OSS ID')
  }
  for (const field of ['durationSeconds', 'sortOrder']) {
    const value = normalizeOptionalSafeInteger(payload[field], field)
    if (value !== undefined) data[field] = value
  }
  if (Object.prototype.hasOwnProperty.call(payload, 'status')) {
    const status = normalizeOptionalAuthText(payload.status, 'status')
    if (status) {
      if (!['0', '1'].includes(status)) throw new TypeError('status 必须为 0 或 1')
      data.status = status
    }
  }
  return data
}

const normalizeCeremonyPayload = (payload) => {
  const allowedFields = new Set(['ceremonyType', 'ceremonyTitle', 'ceremonyDesc', 'ceremonyTime', 'location', 'locationAddress', 'longitude', 'latitude', 'coverOssId', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '礼仪活动请求')
  const ceremonyType = normalizeOptionalAuthText(payload.ceremonyType, 'ceremonyType')
  const ceremonyTitle = normalizeOptionalAuthText(payload.ceremonyTitle, 'ceremonyTitle')
  if (!ceremonyType || !ceremonyTitle) throw new TypeError('请填写活动类型和活动标题')
  const data = { ceremonyType, ceremonyTitle }
  for (const field of ['ceremonyDesc', 'ceremonyTime', 'location', 'locationAddress']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  if (Object.prototype.hasOwnProperty.call(payload, 'status')) {
    const status = normalizeOptionalAuthText(payload.status, 'status')
    if (status) {
      if (!['0', '1'].includes(status)) throw new TypeError('status 必须为 0 或 1')
      data.status = status
    }
  }
  const hasLongitude = payload.longitude !== undefined && payload.longitude !== null && payload.longitude !== ''
  const hasLatitude = payload.latitude !== undefined && payload.latitude !== null && payload.latitude !== ''
  if (hasLongitude !== hasLatitude) throw new TypeError('longitude 和 latitude 必须同时提供')
  if (hasLongitude) {
    const longitude = typeof payload.longitude === 'number' ? payload.longitude : Number(payload.longitude)
    const latitude = typeof payload.latitude === 'number' ? payload.latitude : Number(payload.latitude)
    if (!Number.isFinite(longitude) || !Number.isFinite(latitude)) {
      throw new TypeError('longitude 和 latitude 必须是有限数字')
    }
    data.longitude = longitude
    data.latitude = latitude
  }
  if (payload.coverOssId !== undefined && payload.coverOssId !== null && payload.coverOssId !== '') {
    data.coverOssId = normalizeOssIdString(payload.coverOssId, 'coverOssId')
  }
  const sortOrder = normalizeOptionalSafeInteger(payload.sortOrder, 'sortOrder')
  if (sortOrder !== undefined) {
    data.sortOrder = sortOrder
  }
  return data
}

const normalizeCeremonyGiftPayload = (payload) => {
  const allowedFields = new Set(['giverName', 'giftAmount', 'giftMessage'])
  assertPlainPayload(payload, allowedFields, '礼仪献礼请求')
  if (payload.giftAmount === undefined || payload.giftAmount === null || payload.giftAmount === '') {
    throw new TypeError('请填写献礼金额')
  }
  const giftAmount = typeof payload.giftAmount === 'number' ? payload.giftAmount : Number(payload.giftAmount)
  if (!Number.isFinite(giftAmount)) throw new TypeError('献礼金额必须是有限数字')
  const data = { giftAmount }
  for (const field of ['giverName', 'giftMessage']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  return data
}

const normalizeOptionalOssIdList = (value) => {
  if (value === undefined || value === null || value === '') return undefined
  if (typeof value !== 'string') throw new TypeError('mediaOssIds 必须是字符串')
  const normalized = value.trim()
  if (!/^[1-9]\d*(,[1-9]\d*)*$/.test(normalized)) {
    throw new TypeError('mediaOssIds 必须是以英文逗号分隔的正整数文件标识')
  }
  return normalized
}

const normalizeOptionalSafeInteger = (value, field) => {
  if (value === undefined || value === null || value === '') return undefined
  const numericValue = typeof value === 'number' ? value : Number(value)
  if (!Number.isSafeInteger(numericValue)) throw new TypeError(`${field} 必须是安全整数`)
  return numericValue
}

const normalizeRelativeRecordCreatePayload = (payload) => {
  const allowedFields = new Set(['relativeName', 'relationName', 'eventName', 'eventTime', 'giftAmount', 'recordContent', 'mediaOssIds', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '亲友往来请求')
  const relativeName = typeof payload.relativeName === 'string' ? payload.relativeName.trim() : ''
  if (!relativeName) throw new TypeError('亲友姓名不能为空')
  const data = { relativeName }
  for (const field of ['relationName', 'eventName', 'eventTime', 'recordContent', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  if (payload.giftAmount !== undefined && payload.giftAmount !== '' && payload.giftAmount !== null) {
    const giftAmount = typeof payload.giftAmount === 'number' ? payload.giftAmount : Number(payload.giftAmount)
    if (!Number.isFinite(giftAmount)) {
      throw new TypeError('亲友往来礼金金额必须是有限数字')
    }
    data.giftAmount = giftAmount
  }
  const mediaOssIds = normalizeOptionalOssIdList(payload.mediaOssIds)
  if (mediaOssIds) data.mediaOssIds = mediaOssIds
  const sortOrder = normalizeOptionalSafeInteger(payload.sortOrder, 'sortOrder')
  if (sortOrder !== undefined) data.sortOrder = sortOrder
  return data
}

const normalizeGrowthRecordCreatePayload = (payload) => {
  const allowedFields = new Set(['lineagePersonId', 'recordType', 'recordTitle', 'recordContent', 'recordDate', 'remindTime', 'mediaOssIds', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '成长记录请求')
  const recordTitle = typeof payload.recordTitle === 'string' ? payload.recordTitle.trim() : ''
  if (!recordTitle) throw new TypeError('成长记录标题不能为空')
  const data = { recordTitle }
  for (const field of ['recordType', 'recordContent', 'recordDate', 'remindTime', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  const lineagePersonId = normalizeOptionalSafeInteger(payload.lineagePersonId, 'lineagePersonId')
  if (lineagePersonId !== undefined) data.lineagePersonId = lineagePersonId
  const mediaOssIds = normalizeOptionalOssIdList(payload.mediaOssIds)
  if (mediaOssIds) data.mediaOssIds = mediaOssIds
  const sortOrder = normalizeOptionalSafeInteger(payload.sortOrder, 'sortOrder')
  if (sortOrder !== undefined) data.sortOrder = sortOrder
  return data
}

const normalizeMemoCreatePayload = (payload) => {
  const allowedFields = new Set(['memoTitle', 'memoContent', 'remindTime', 'completed', 'mediaOssIds', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '备忘请求')
  const memoTitle = typeof payload.memoTitle === 'string' ? payload.memoTitle.trim() : ''
  if (!memoTitle) throw new TypeError('备忘标题不能为空')
  const data = { memoTitle }
  for (const field of ['memoContent', 'remindTime', 'completed', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  const mediaOssIds = normalizeOptionalOssIdList(payload.mediaOssIds)
  if (mediaOssIds) data.mediaOssIds = mediaOssIds
  const sortOrder = normalizeOptionalSafeInteger(payload.sortOrder, 'sortOrder')
  if (sortOrder !== undefined) data.sortOrder = sortOrder
  return data
}

const normalizeMeritRecordCreatePayload = (payload) => {
  const allowedFields = new Set(['donorName', 'meritTitle', 'meritType', 'meritContent', 'amount', 'meritTime', 'sortOrder', 'status'])
  assertPlainPayload(payload, allowedFields, '功德记录请求')
  const donorName = typeof payload.donorName === 'string' ? payload.donorName.trim() : ''
  const meritTitle = typeof payload.meritTitle === 'string' ? payload.meritTitle.trim() : ''
  if (!donorName || !meritTitle) throw new TypeError('功德记录捐赠人和标题不能为空')
  const data = { donorName, meritTitle }
  for (const field of ['meritType', 'meritContent', 'meritTime', 'status']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  if (payload.amount !== undefined && payload.amount !== '' && payload.amount !== null) {
    const amount = typeof payload.amount === 'number' ? payload.amount : Number(payload.amount)
    if (!Number.isFinite(amount)) throw new TypeError('功德金额必须是有限数字')
    data.amount = amount
  }
  const sortOrder = normalizeOptionalSafeInteger(payload.sortOrder, 'sortOrder')
  if (sortOrder !== undefined) data.sortOrder = sortOrder
  return data
}

const normalizeResourcePathId = (value, label) => {
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw new TypeError(`${label}必须是有效的正整数标识`)
}

const normalizeNotificationText = (value, field) => {
  if (value === undefined || value === null) return ''
  if (typeof value !== 'string') {
    throw createRequestError(`通知详情字段 ${field} 无效`, 'NOTIFICATION_DETAIL_RESPONSE_INVALID')
  }
  return value
}

const normalizeNotificationDetail = (value, expectedNotificationId) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('通知详情响应格式无效', 'NOTIFICATION_DETAIL_RESPONSE_INVALID')
  }
  const notificationId = normalizeOptionalNumericId(value.notificationId, '通知标识', 'NOTIFICATION_DETAIL_RESPONSE_INVALID')
  if (!notificationId || notificationId !== expectedNotificationId) {
    throw createRequestError('通知详情响应标识不匹配', 'NOTIFICATION_DETAIL_RESPONSE_INVALID')
  }
  return {
    notificationId,
    genealogyId: normalizeOptionalNumericId(value.genealogyId, '通知家谱标识', 'NOTIFICATION_DETAIL_RESPONSE_INVALID'),
    genealogyNo: normalizeNotificationText(value.genealogyNo, 'genealogyNo'),
    genealogyName: normalizeNotificationText(value.genealogyName, 'genealogyName'),
    senderUserId: normalizeOptionalNumericId(value.senderUserId, '通知发送人标识', 'NOTIFICATION_DETAIL_RESPONSE_INVALID'),
    senderNickName: normalizeNotificationText(value.senderNickName, 'senderNickName'),
    senderPhone: normalizeNotificationText(value.senderPhone, 'senderPhone'),
    noticeType: normalizeNotificationText(value.noticeType, 'noticeType'),
    noticeTitle: normalizeNotificationText(value.noticeTitle, 'noticeTitle'),
    noticeContent: normalizeNotificationText(value.noticeContent, 'noticeContent'),
    bizType: normalizeNotificationText(value.bizType, 'bizType'),
    bizId: normalizeOptionalNumericId(value.bizId, '通知关联业务标识', 'NOTIFICATION_DETAIL_RESPONSE_INVALID'),
    bizSummary: normalizeNotificationText(value.bizSummary, 'bizSummary'),
    publishTime: normalizeNotificationText(value.publishTime, 'publishTime'),
    readStatus: normalizeNotificationText(value.readStatus, 'readStatus'),
    readTime: normalizeNotificationText(value.readTime, 'readTime'),
    status: normalizeNotificationText(value.status, 'status'),
    remark: normalizeNotificationText(value.remark, 'remark')
  }
}

const requireRemoteResource = (label, operation) => {
  if (hasRemoteConfig()) return
  throw createRequestError(`${label}${operation}需要真实服务，当前本地预览不会伪造结果`, operation === '读取' ? 'REMOTE_READ_REQUIRED' : 'REMOTE_WRITE_REQUIRED')
}

const readRemoteList = async (url, label, requestOptions = {}) => {
  requireRemoteResource(label, '读取')
  const result = await requestStrict({ url, method: 'GET' }, {
    requestController: requestOptions.requestController ?? null
  })
  if (!Array.isArray(result)) {
    throw createRequestError(`${label}响应不是列表`, 'LIST_RESPONSE_INVALID')
  }
  return result
}

const readRemoteObject = async (url, label, requestOptions = {}) => {
  requireRemoteResource(label, '读取')
  const result = await requestStrict({ url, method: 'GET' }, {
    requestController: requestOptions.requestController ?? null
  })
  if (!result || typeof result !== 'object' || Array.isArray(result)) {
    throw createRequestError(`${label}响应不是对象`, 'OBJECT_RESPONSE_INVALID')
  }
  return result
}

const writeRemoteObject = (url, method, data, label, requestOptions = {}) => {
  requireRemoteResource(label, '写入')
  return requestStrict({ url, method, ...(data === undefined ? {} : { data }) }, {
    requestController: requestOptions.requestController ?? null
  })
}

const writeRemoteVoid = async (url, method, data, label, requestOptions = {}) => {
  requireRemoteResource(label, '写入')
  await requestStrict({ url, method, ...(data === undefined ? {} : { data }) }, {
    requireData: false,
    requestController: requestOptions.requestController ?? null
  })
  return null
}

const normalizePhoneChangePayload = (payload) => {
  assertPlainPayload(payload, new Set(['phone', 'smsCode']), '换绑手机号请求')
  if (typeof payload.phone !== 'string' || !/^1\d{10}$/.test(payload.phone.trim())) {
    throw new TypeError('新手机号格式无效')
  }
  return { phone: payload.phone.trim(), smsCode: assertSmsCode(payload.smsCode) }
}

const normalizeMemberUpdatePayload = (payload) => {
  assertPlainPayload(payload, new Set(['memberName', 'relationName', 'roleType', 'lineagePersonId']), '成员更新请求')
  const data = {}
  for (const field of ['memberName', 'relationName', 'roleType']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  if (payload.lineagePersonId !== undefined && payload.lineagePersonId !== null && payload.lineagePersonId !== '') {
    data.lineagePersonId = Number(normalizeResourcePathId(payload.lineagePersonId, '世系人物标识'))
  }
  if (!Object.keys(data).length) throw new TypeError('请至少填写一项要更新的成员信息')
  return data
}

const normalizeVipOrderPayload = (payload) => {
  assertPlainPayload(payload, new Set(['packageId', 'genealogyId', 'payType']), 'VIP 订单请求')
  const data = { packageId: Number(normalizeResourcePathId(payload.packageId, '套餐标识')) }
  if (payload.genealogyId !== undefined && payload.genealogyId !== null && payload.genealogyId !== '') {
    data.genealogyId = Number(normalizeResourcePathId(payload.genealogyId, '家谱标识'))
  }
  const payType = normalizeOptionalAuthText(payload.payType, '支付方式')
  if (payType) data.payType = payType
  return data
}

const normalizeSiteArticleQuery = (payload = {}) => {
  assertPlainPayload(payload, new Set(['articleType', 'limit']), '官网文章查询')
  const data = {}
  const articleType = normalizeOptionalAuthText(payload.articleType, '官网文章类型')
  if (articleType) data.articleType = articleType
  if (payload.limit !== undefined && payload.limit !== null && payload.limit !== '') {
    const limit = typeof payload.limit === 'number' ? payload.limit : Number(payload.limit)
    if (!Number.isSafeInteger(limit) || limit < 1) throw new TypeError('官网文章数量上限必须是正整数')
    data.limit = limit
  }
  return data
}

const normalizeSitePageKey = (pageKey) => {
  const normalized = normalizeOptionalAuthText(pageKey, '官网页面标识')
  if (!normalized) throw new TypeError('官网页面标识不能为空')
  return normalized
}

const normalizeJoinApplicationPayload = (payload) => {
  assertPlainPayload(payload, new Set(['applicantName', 'phone', 'relationDesc', 'applyReason', 'inviterUserId']), '加入申请请求')
  const data = {}
  for (const field of ['applicantName', 'phone', 'relationDesc', 'applyReason']) {
    const value = normalizeOptionalAuthText(payload[field], field)
    if (value) data[field] = value
  }
  if (payload.inviterUserId !== undefined && payload.inviterUserId !== null && payload.inviterUserId !== '') {
    data.inviterUserId = Number(normalizeResourcePathId(payload.inviterUserId, '邀请人标识'))
  }
  return data
}

const normalizeJoinAuditPayload = (payload) => {
  assertPlainPayload(payload, new Set(['status', 'auditRemark']), '加入申请审核请求')
  const status = normalizeOptionalAuthText(payload.status, '审核状态')
  if (!status) throw new TypeError('加入申请审核缺少 status')
  const data = { status }
  const auditRemark = normalizeOptionalAuthText(payload.auditRemark, '审核备注')
  if (auditRemark) data.auditRemark = auditRemark
  return data
}

const normalizeCeremonyInviteePayload = (payload) => {
  assertPlainPayload(payload, new Set(['inviteeUserIds']), '活动受邀人请求')
  if (!Array.isArray(payload.inviteeUserIds)) {
    throw new TypeError('inviteeUserIds必须是数组')
  }
  const inviteeUserIds = payload.inviteeUserIds.map((value) => {
    const id = normalizeResourcePathId(value, '受邀业务用户标识')
    const numericId = Number(id)
    if (!Number.isSafeInteger(numericId)) {
      throw createRequestError('受邀业务用户标识超出 APP 安全整数范围，需后端统一字符串 ID 合同', 'CEREMONY_INVITEE_ID_UNSAFE')
    }
    return numericId
  })
  if (new Set(inviteeUserIds).size !== inviteeUserIds.length) {
    throw new TypeError('inviteeUserIds不能包含重复标识')
  }
  return { inviteeUserIds }
}

const normalizeCeremonyInvitationResponsePayload = (payload) => {
  assertPlainPayload(payload, new Set(['inviteStatus']), '活动邀请响应请求')
  if (!['ACCEPTED', 'DECLINED'].includes(payload.inviteStatus)) {
    throw new TypeError('inviteStatus仅允许ACCEPTED或DECLINED')
  }
  return { inviteStatus: payload.inviteStatus }
}

const normalizeGenerationPoemWritePayload = (payload) => {
  assertPlainPayload(payload, new Set(['generationNo', 'generationText', 'description', 'sortOrder', 'status']), '字辈请求')
  const generationNo = Number(payload.generationNo)
  if (!Number.isSafeInteger(generationNo) || generationNo < 1 || generationNo > 2147483647) {
    throw new TypeError('世代序号必须是 1 到 2147483647 的整数')
  }
  const generationText = normalizeOptionalAuthText(payload.generationText, '字辈文字')
  if (!generationText || Array.from(generationText).length > 50) throw new TypeError('字辈文字不能为空且不能超过 50 个字符')
  const data = { generationNo, generationText }
  const description = normalizeOptionalAuthText(payload.description, '字辈说明')
  if (description) {
    if (Array.from(description).length > 500) throw new TypeError('字辈说明不能超过 500 个字符')
    data.description = description
  }
  if (payload.sortOrder !== undefined && payload.sortOrder !== null && payload.sortOrder !== '') {
    const sortOrder = Number(payload.sortOrder)
    if (!Number.isSafeInteger(sortOrder)) throw new TypeError('排序值必须是整数')
    data.sortOrder = sortOrder
  }
  const status = normalizeOptionalAuthText(payload.status, '状态')
  if (status) data.status = status
  return data
}

const normalizeGenerationPoemId = (value, label) => {
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) return value
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return String(value)
  throw createRequestError(`字辈${label}无效`, 'GENERATION_POEM_RESPONSE_INVALID')
}

const normalizeGenerationPoemNumber = (value, label) => {
  if (typeof value === 'number' && Number.isSafeInteger(value) && value > 0) return value
  if (typeof value === 'string' && /^[1-9]\d*$/.test(value)) {
    const normalized = Number(value)
    if (Number.isSafeInteger(normalized)) return normalized
  }
  throw createRequestError(`字辈${label}无效`, 'GENERATION_POEM_RESPONSE_INVALID')
}

const normalizeGenerationPoemText = (value, label, { required = false, maxLength = null } = {}) => {
  if (value === undefined || value === null) {
    if (required) throw createRequestError(`字辈缺少${label}`, 'GENERATION_POEM_RESPONSE_INVALID')
    return ''
  }
  if (typeof value !== 'string') throw createRequestError(`字辈${label}无效`, 'GENERATION_POEM_RESPONSE_INVALID')
  const normalized = value.trim()
  if (required && !normalized) throw createRequestError(`字辈缺少${label}`, 'GENERATION_POEM_RESPONSE_INVALID')
  if (maxLength !== null && Array.from(normalized).length > maxLength) {
    throw createRequestError(`字辈${label}超出合同长度`, 'GENERATION_POEM_RESPONSE_INVALID')
  }
  return normalized
}

const normalizeGenerationPoemStatus = (value) => {
  if (value === '0' || value === '1') return value
  throw createRequestError('字辈状态无效', 'GENERATION_POEM_RESPONSE_INVALID')
}

const normalizeGenerationPoemRows = (value, expectedGenealogyId) => {
  if (!Array.isArray(value)) throw createRequestError('字辈响应不是列表', 'GENERATION_POEM_RESPONSE_INVALID')
  const rows = value.map((item) => {
    if (!item || typeof item !== 'object' || Array.isArray(item)) {
      throw createRequestError('字辈响应包含无效条目', 'GENERATION_POEM_RESPONSE_INVALID')
    }
    const genealogyId = normalizeGenerationPoemId(item.genealogyId, '家谱标识')
    if (genealogyId !== expectedGenealogyId) {
      throw createRequestError('字辈响应家谱标识与请求不匹配', 'GENERATION_POEM_RESPONSE_INVALID')
    }
    return {
      poemId: normalizeGenerationPoemId(item.poemId, '标识'),
      genealogyId,
      genealogyNo: normalizeGenerationPoemText(item.genealogyNo, '家谱编号'),
      genealogyName: normalizeGenerationPoemText(item.genealogyName, '家谱名称'),
      generationNo: normalizeGenerationPoemNumber(item.generationNo, '世代'),
      generationText: normalizeGenerationPoemText(item.generationText, '文字', { required: true, maxLength: 50 }),
      description: normalizeGenerationPoemText(item.description, '说明', { maxLength: 500 }),
      sortOrder: item.sortOrder,
      status: normalizeGenerationPoemStatus(item.status),
    }
  })
  if (new Set(rows.map((item) => item.poemId)).size !== rows.length) {
    throw createRequestError('字辈响应包含重复标识', 'GENERATION_POEM_RESPONSE_INVALID')
  }
  if (new Set(rows.map((item) => item.generationNo)).size !== rows.length) {
    throw createRequestError('字辈响应包含重复世代', 'GENERATION_POEM_RESPONSE_INVALID')
  }
  return rows.sort((left, right) => left.generationNo - right.generationNo)
}

const normalizeGenerationPoemBatchPayload = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload) || Object.getPrototypeOf(payload) !== Object.prototype) {
    throw new TypeError('字辈批量请求必须是普通对象')
  }
  if (Object.keys(payload).some((field) => !['poemText', 'disableMissing'].includes(field))) {
    throw new TypeError('字辈批量请求包含未声明字段')
  }
  const poemText = normalizeGenerationPoemText(payload.poemText, '内容', { required: true, maxLength: 26000 })
  const data = { poemText }
  if (payload.disableMissing !== undefined) {
    if (typeof payload.disableMissing !== 'boolean') throw new TypeError('字辈停用策略必须是布尔值')
    data.disableMissing = payload.disableMissing
  }
  return data
}

const normalizeGenerationPoemPreview = (value, expectedGenealogyId) => {
  if (!value || typeof value !== 'object' || Array.isArray(value)) {
    throw createRequestError('字辈批量预览响应不是对象', 'GENERATION_POEM_RESPONSE_INVALID')
  }
  const genealogyId = normalizeGenerationPoemId(value.genealogyId, '预览家谱标识')
  if (genealogyId !== expectedGenealogyId) {
    throw createRequestError('字辈预览家谱标识与请求不匹配', 'GENERATION_POEM_RESPONSE_INVALID')
  }
  const counts = ['createCount', 'updateCount', 'keepCount', 'disableCount']
  const preview = { genealogyId, items: Array.isArray(value.items) ? value.items : null }
  for (const field of counts) {
    if (!Number.isSafeInteger(value[field]) || value[field] < 0) {
      throw createRequestError(`字辈预览${field}无效`, 'GENERATION_POEM_RESPONSE_INVALID')
    }
    preview[field] = value[field]
  }
  if (preview.items === null) {
    throw createRequestError('字辈预览缺少明细列表', 'GENERATION_POEM_RESPONSE_INVALID')
  }
  return preview
}

const normalizeLineageWritePayload = (payload) => {
  if (!payload || typeof payload !== 'object' || Array.isArray(payload) || Object.getPrototypeOf(payload) !== Object.prototype) {
    throw new TypeError('人物写入请求必须是普通对象')
  }
  const allowedFields = new Set([
    'bindingMode',
    'appUserId',
    'personNo',
    'name',
    'aliasName',
    'sex',
    'generationName',
    'fatherId',
    'motherId',
    'avatarOssId',
    'birthDate',
    'birthLunar',
    'birthPlace',
    'deathDate',
    'deathLunar',
    'deathPlace',
    'burialPlace',
    'biography',
    'remark',
    'relationName',
    'generation',
    'personStatus',
    'sortOrder'
  ])
  for (const field of Object.keys(payload)) {
    if (!allowedFields.has(field)) throw new TypeError(`人物写入包含未声明字段：${field}`)
  }
  const name = normalizeLineagePersonText(payload.name, '姓名', { required: true })
  if (name.length > 20) throw new TypeError('人物姓名长度超出当前页面合同')
  const bindingMode = normalizeLineagePersonText(payload.bindingMode, '身份认领方式')
  if (!['NONE', 'SELF', 'SPECIFIED'].includes(bindingMode)) {
    throw new TypeError('人物身份认领方式必须是 NONE、SELF 或 SPECIFIED')
  }
  const data = { bindingMode, name }
  if (bindingMode === 'SPECIFIED') {
    if (payload.appUserId === undefined || payload.appUserId === null || payload.appUserId === '') {
      throw new TypeError('指定业务用户绑定必须提供业务用户标识')
    }
    data.appUserId = normalizeLineagePersonIdentity(payload.appUserId, '绑定用户标识')
  } else if (payload.appUserId !== undefined && payload.appUserId !== null && payload.appUserId !== '') {
    throw new TypeError(`${bindingMode} 身份认领不能提供业务用户标识`)
  }
  for (const [field, label] of [
    ['fatherId', '父亲标识'],
    ['motherId', '母亲标识']
  ]) {
    if (payload[field] === undefined || payload[field] === null || payload[field] === '') continue
    data[field] = normalizeLineagePersonIdentity(payload[field], label)
  }
  if (payload.avatarOssId !== undefined && payload.avatarOssId !== null && payload.avatarOssId !== '') {
    data.avatarOssId = normalizeOssIdString(payload.avatarOssId, '头像文件标识')
  }
  if (payload.generation !== undefined) {
    if (!Number.isSafeInteger(payload.generation) || payload.generation < 1) {
      throw new TypeError('人物世代必须是正安全整数')
    }
    data.generation = payload.generation
  }
  for (const [field, label, maxLength] of [
    ['personNo', '人物编号', null],
    ['sex', '性别', null],
    ['generationName', '字辈', 12],
    ['aliasName', '别名或曾用名', null],
    ['birthLunar', '出生农历', null],
    ['birthPlace', '出生地', null],
    ['deathLunar', '逝世农历', null],
    ['deathPlace', '逝世地', null],
    ['burialPlace', '安葬地', null],
    ['biography', '人物简介', 500],
    ['remark', '备注', null],
    ['relationName', '关系显示名称', null],
    ['personStatus', '人物状态', null]
  ]) {
    if (payload[field] === undefined) continue
    const value = normalizeLineagePersonText(payload[field], label)
    if (maxLength && value.length > maxLength) throw new TypeError(`人物${label}长度超出当前页面合同`)
    if (value) data[field] = value
  }
  for (const [field, label] of [
    ['birthDate', '出生日期'],
    ['deathDate', '离世日期']
  ]) {
    if (payload[field] === undefined) continue
    const value = normalizeLineagePersonDate(payload[field], label)
    if (value) data[field] = value
  }
  if (data.birthDate && data.deathDate && data.deathDate < data.birthDate) {
    throw new TypeError('人物离世日期不能早于出生日期')
  }
  if (payload.sortOrder !== undefined && payload.sortOrder !== null && payload.sortOrder !== '') {
    const sortOrder = typeof payload.sortOrder === 'number' ? payload.sortOrder : Number(payload.sortOrder)
    if (!Number.isSafeInteger(sortOrder)) throw new TypeError('人物排序值必须是安全整数')
    data.sortOrder = sortOrder
  }
  return data
}

const lineageRelationPath = Object.freeze({
  FATHER: 'parents',
  MOTHER: 'parents',
  SPOUSE: 'spouses',
  SIBLING: 'siblings',
  SON: 'children',
  DAUGHTER: 'children'
})

const requireLineageWriteRequestController = (requestOptions) => {
  if (!requestOptions || typeof requestOptions !== 'object' || Array.isArray(requestOptions) || Object.getPrototypeOf(requestOptions) !== Object.prototype) {
    throw new TypeError('人物写入请求选项必须是普通对象')
  }
  const fields = Object.keys(requestOptions)
  if (fields.some((field) => field !== 'requestController')) {
    throw new TypeError('人物写入请求选项包含未声明字段')
  }
  return requestOptions.requestController ?? null
}

export const appApi = {
  async getCaptchaRequirement({ operationCode, subject }, requestOptions = {}) {
    requireRemoteAuth()
    return requestAuth({
      url: `/genealogy/app/auth/verification/${encodeURIComponent(assertAuthVerificationOperation(operationCode))}/require`,
      method: 'GET',
      data: { tenantId: runtimeConfig.tenantId, subject }
    }, requestOptions)
  },
  async sendSmsCode({ operationCode, phone, validToken }, requestOptions = {}) {
    requireRemoteAuth()
    const normalizedValidToken = normalizeOptionalValidToken(validToken)
    return requestAuthVoid({
      url: `/genealogy/app/auth/sms/${encodeURIComponent(assertAuthVerificationOperation(operationCode))}/code`,
      method: 'POST',
      data: {
        tenantId: runtimeConfig.tenantId,
        grantType: 'sms',
        phone,
        ...(normalizedValidToken ? { validToken: normalizedValidToken } : {})
      }
    }, requestOptions)
  },
  async loginWithPassword({ phone, passwordHash, validToken }, requestOptions = {}) {
    requireRemoteAuth()
    const normalizedValidToken = normalizeOptionalValidToken(validToken)
    const result = await requestAuth({
      url: '/genealogy/app/auth/login',
      method: 'POST',
      data: {
        tenantId: runtimeConfig.tenantId,
        grantType: 'password',
        phone,
        password: assertPasswordHash(passwordHash),
        ...(normalizedValidToken ? { validToken: normalizedValidToken } : {})
      }
    }, requestOptions)
    return saveLogin(result)
  },
  async loginWithSms({ phone, smsCode }, requestOptions = {}) {
    requireRemoteAuth()
    const result = await requestAuth({
      url: '/genealogy/app/auth/login/sms',
      method: 'POST',
      data: { tenantId: runtimeConfig.tenantId, grantType: 'sms', phone, smsCode: assertSmsCode(smsCode) }
    }, requestOptions)
    return saveLogin(result)
  },
  async registerWithPassword({ phone, passwordHash, smsCode, nickName }, requestOptions = {}) {
    requireRemoteAuth()
    const normalizedNickName = normalizeOptionalAuthText(nickName, '昵称')
    const result = await requestAuth({
      url: '/genealogy/app/auth/register',
      method: 'POST',
      data: {
        tenantId: runtimeConfig.tenantId,
        grantType: 'password',
        phone,
        password: assertPasswordHash(passwordHash),
        smsCode: assertSmsCode(smsCode),
        ...(normalizedNickName ? { nickName: normalizedNickName } : {})
      }
    }, requestOptions)
    return saveLogin(result)
  },
  async resetPassword({ phone, passwordHash, smsCode }, requestOptions = {}) {
    requireRemoteAuth()
    return requestAuthVoid({
      url: '/genealogy/app/auth/password/reset',
      method: 'PUT',
      data: {
        tenantId: runtimeConfig.tenantId,
        grantType: 'password',
        phone,
        newPassword: assertPasswordHash(passwordHash),
        smsCode: assertSmsCode(smsCode)
      }
    }, requestOptions)
  },
  async changePassword({ oldPasswordHash, newPasswordHash }, requestOptions = {}) {
    requireRemoteAuth()
    await requestStrict({
      url: '/genealogy/app/auth/password',
      method: 'PUT',
      data: {
        oldPassword: assertPasswordHash(oldPasswordHash),
        newPassword: assertPasswordHash(newPasswordHash)
      }
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async deactivateAccount({ smsCode }, requestOptions = {}) {
    requireRemoteAuth()
    await requestStrict({
      url: '/genealogy/app/auth/account/deactivate',
      method: 'POST',
      data: { smsCode: assertSmsCode(smsCode) }
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async logout(requestOptions = {}) {
    if (resolveRuntimeMode() !== 'remote') return null
    await requestStrict({
      url: '/genealogy/app/auth/logout',
      method: 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async submitFeedback(payload, requestOptions = {}) {
    const data = normalizeFeedbackPayload(payload)
    if (!requestOptions || typeof requestOptions !== 'object' || Array.isArray(requestOptions) || Object.getPrototypeOf(requestOptions) !== Object.prototype) {
      throw new TypeError('反馈请求选项必须是普通对象')
    }
    const optionNames = Object.getOwnPropertyNames(requestOptions)
    const optionDescriptors = Object.getOwnPropertyDescriptors(requestOptions)
    if (
      Object.getOwnPropertySymbols(requestOptions).length > 0 ||
      optionNames.some((field) => field !== 'requestController') ||
      optionNames.some((field) => !Object.prototype.hasOwnProperty.call(optionDescriptors[field], 'value'))
    ) {
      throw new TypeError('反馈请求选项包含未声明字段')
    }
    const runtimeMode = resolveRuntimeMode()
    if (runtimeMode !== 'remote') {
      throw createRequestError('当前为本地预览模式，反馈未提交服务器', 'WRITE_UNAVAILABLE')
    }
    return requestStrict({
      url: '/genealogy/app/feedback',
      method: 'POST',
      data
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
  },
  async getProfile(requestOptions = {}) {
    if (!hasRemoteConfig()) {
      throw createRequestError('个人资料需要真实服务读取，当前本地预览不伪造资料', 'REMOTE_READ_REQUIRED')
    }
    const result = await requestStrict({
      url: '/genealogy/app/auth/profile',
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeAppProfile(result)
  },
  async updateProfile(payload, requestOptions = {}) {
    const data = normalizeProfileUpdatePayload(payload)
    if (!hasRemoteConfig()) {
      throw createRequestError('个人资料更新需要真实服务，当前本地预览不伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    const result = await requestStrict({
      url: '/genealogy/app/auth/profile',
      method: 'PUT',
      data
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeAppProfile(result)
  },
  async initializeResumableUpload(payload, requestOptions = {}) {
    const data = normalizeResumableInitPayload(payload)
    if (!hasRemoteConfig()) {
      throw createRequestError('文件上传需要真实服务，当前本地预览不伪造回执', 'REMOTE_WRITE_REQUIRED')
    }
    const result = await requestStrict({
      url: '/genealogy/app/files/resumable/init',
      method: 'POST',
      data
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeResumableInitResult(result)
  },
  async uploadResumableChunk(payload, requestOptions = {}) {
    const allowedFields = new Set(['uploadId', 'chunkIndex', 'chunkMd5', 'filePath'])
    assertPlainPayload(payload, allowedFields, '文件分片请求')
    if (!Number.isInteger(payload.chunkIndex) || payload.chunkIndex < 0 || payload.chunkIndex > 2147483647) {
      throw new TypeError('chunkIndex必须是非负 int32')
    }
    if (typeof payload.filePath !== 'string' || !payload.filePath.trim()) {
      throw new TypeError('filePath必须是非空字符串')
    }
    if (!hasRemoteConfig()) {
      throw createRequestError('文件上传需要真实服务，当前本地预览不伪造回执', 'REMOTE_WRITE_REQUIRED')
    }
    return requestNativeFileChunk({
      uploadId: normalizeUploadId(payload.uploadId, 'uploadId'),
      chunkIndex: payload.chunkIndex,
      chunkMd5: normalizeUploadMd5(payload.chunkMd5, 'chunkMd5'),
      filePath: payload.filePath.trim()
    }, requestOptions)
  },
  async uploadBrowserResumableChunk(payload, file, requestOptions = {}) {
    const allowedFields = new Set(['uploadId', 'chunkIndex', 'chunkMd5'])
    assertPlainPayload(payload, allowedFields, '浏览器文件分片请求')
    if (!Number.isInteger(payload.chunkIndex) || payload.chunkIndex < 0 || payload.chunkIndex > 2147483647) {
      throw new TypeError('chunkIndex必须是非负 int32')
    }
    if (!file || typeof file !== 'object') {
      throw new TypeError('浏览器文件分片必须提供文件对象')
    }
    if (!hasRemoteConfig()) {
      throw createRequestError('文件上传需要真实服务，当前本地预览不伪造回执', 'REMOTE_WRITE_REQUIRED')
    }
    return requestBrowserFileChunk({
      uploadId: normalizeUploadId(payload.uploadId, 'uploadId'),
      chunkIndex: payload.chunkIndex,
      chunkMd5: normalizeUploadMd5(payload.chunkMd5, 'chunkMd5'),
      file
    }, requestOptions)
  },
  async completeResumableUpload(payload, requestOptions = {}) {
    const data = normalizeResumableCompletePayload(payload)
    if (!hasRemoteConfig()) {
      throw createRequestError('文件上传需要真实服务，当前本地预览不伪造回执', 'REMOTE_WRITE_REQUIRED')
    }
    const result = await requestStrict({
      url: '/genealogy/app/files/resumable/complete',
      method: 'POST',
      data
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeResumableCompleteResult(result)
  },
  async getRegionChildren(parentCode, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('地区选择需要真实读取服务，当前本地预览不会伪造地区列表')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const result = await requestStrict({
      url: '/genealogy/app/region/children',
      method: 'GET',
      data: { parentCode: normalizeRegionParentCode(parentCode) }
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeRegionSelectorItems(result)
  },
  async getRegionPath(regionCode, requestOptions = {}) {
    requireRemoteResource('行政区划路径', '读取')
    const result = await requestStrict({
      url: `/genealogy/app/region/path/${encodeURIComponent(normalizeRegionCode(regionCode))}`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    if (!Array.isArray(result)) {
      throw createRequestError('行政区划路径响应不是列表', 'REGION_PATH_RESPONSE_INVALID')
    }
    return result
  },
  async searchRegions(payload, requestOptions = {}) {
    requireRemoteResource('行政区划搜索', '读取')
    const result = await requestStrict({
      url: '/genealogy/app/region/search',
      method: 'GET',
      data: normalizeRegionSearchPayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
    if (!Array.isArray(result)) {
      throw createRequestError('行政区划搜索响应不是列表', 'REGION_SEARCH_RESPONSE_INVALID')
    }
    return result
  },
  async getRegion(regionCode, requestOptions = {}) {
    requireRemoteResource('行政区划详情', '读取')
    const result = await requestStrict({
      url: `/genealogy/app/region/${encodeURIComponent(normalizeRegionCode(regionCode))}`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    if (!result || typeof result !== 'object' || Array.isArray(result)) {
      throw createRequestError('行政区划详情响应不是对象', 'REGION_DETAIL_RESPONSE_INVALID')
    }
    return result
  },
  async getMyGenealogies(requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('我的家谱需要真实读取服务，当前本地预览不会伪造家谱列表')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const result = await requestStrict({
      url: '/genealogy/app/genealogies/mine',
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeMyGenealogies(result)
  },
  async getGenealogyQuota(requestOptions = {}) {
    requireRemoteResource('家谱配额', '读取')
    const result = await requestStrict({
      url: '/genealogy/app/genealogies/quota',
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeGenealogyQuota(result)
  },
  async createGenealogy(payload, requestOptions = {}) {
    const data = normalizeGenealogyCreatePayload(payload)
    if (!hasRemoteConfig()) {
      throw createRequestError('创建家谱需要真实服务，当前本地预览不会伪造创建成功', 'REMOTE_WRITE_REQUIRED')
    }
    const result = await requestStrict({
      url: '/genealogy/app/genealogies',
      method: 'POST',
      data
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeCreatedGenealogy(result)
  },
  async getGenealogy(genealogyId) {
    return hasRemoteConfig() ? request({ url: `/genealogy/app/genealogies/${genealogyId}` }) : genealogies.find((item) => String(item.id) === String(genealogyId))
  },
  async getGenealogySettings(genealogyId, requestOptions = {}) {
    const normalizedId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) {
      const error = new Error('家谱设置需要真实读取服务，当前本地预览不会伪造可编辑数据')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedId}`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeGenealogySettings(result, normalizedId)
  },
  async updateGenealogy(genealogyId, payload, requestOptions = {}) {
    const normalizedId = normalizeGenealogyPathId(genealogyId)
    const data = normalizeGenealogyUpdatePayload(payload)
    if (!hasRemoteConfig()) {
      throw createRequestError('更新家谱需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedId}`,
      method: 'PUT',
      data
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
  },
  async getOverview(genealogyId, requestOptions = {}) {
    const normalizedId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) {
      const error = new Error('家谱概览需要真实读取服务，当前本地预览不会伪造概览数据')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedId}/overview`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    const overview = normalizeAppGenealogy(result)
    if (overview.id !== normalizedId) {
      throw createRequestError('家谱概览响应标识不匹配', 'GENEALOGY_RESPONSE_INVALID')
    }
    return overview
  },
  async getTree(genealogyId, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('世系树需要真实读取服务，当前本地预览不会伪造人物节点')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const normalizedId = normalizeGenealogyPathId(genealogyId)
    const tree = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedId}/lineage/tree`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeLineageTree(tree)
  },
  async getPerson(genealogyId, personId, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('人物详情需要真实读取服务，当前本地预览不会伪造成员资料')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedPersonId = normalizeLineagePersonIdentity(personId, '人物标识')
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/lineage/persons/${normalizedPersonId}`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeLineagePersonDetail(result, normalizedGenealogyId, normalizedPersonId)
  },
  async getPersonPage(genealogyId, { pageNum = 1, pageSize = 10, keyword = '' } = {}, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('成员目录需要真实读取服务，当前本地预览不会伪造目录数据')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    if (!Number.isSafeInteger(pageNum) || pageNum < 1) throw new TypeError('成员目录页码无效')
    if (!Number.isSafeInteger(pageSize) || pageSize < 1) throw new TypeError('成员目录页大小无效')
    if (typeof keyword !== 'string') throw new TypeError('成员目录关键词无效')
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/lineage/persons/page`,
      method: 'GET',
      data: { pageNum, pageSize, ...(keyword.trim() ? { keyword: keyword.trim() } : {}) }
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return normalizeLineagePersonPage(result, normalizedGenealogyId)
  },
  async getFeedComments(genealogyId, feedId, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('动态评论需要真实读取服务，当前本地预览不会伪造评论数据')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeFeedCommentId(feedId, '动态标识')
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/feeds/${normalizedFeedId}/comments`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeFeedComments(result, normalizedGenealogyId, normalizedFeedId)
  },
  async createFeedComment(genealogyId, feedId, payload, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('动态评论需要真实服务，当前本地预览不会伪造提交成功')
      error.code = 'REMOTE_WRITE_REQUIRED'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeFeedCommentId(feedId, '动态标识')
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/feeds/${normalizedFeedId}/comments`,
      method: 'POST',
      data: normalizeFeedCommentPayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async getGenerationPoems(genealogyId, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('字辈列表需要真实读取服务，当前本地预览不会伪造字辈数据')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/generation-poems`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeGenerationPoemRows(result, normalizedGenealogyId)
  },
  async getGenerationPoemManagement(genealogyId, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('字辈维护列表需要真实读取服务，当前本地预览不会伪造管理权限')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/generation-poems/management`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeGenerationPoemRows(result, normalizedGenealogyId)
  },
  async previewGenerationPoemBatch(genealogyId, payload, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('字辈批量预览需要真实服务，当前本地预览不会伪造差异结果')
      error.code = 'REMOTE_READ_REQUIRED'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/generation-poems/batch/preview`,
      method: 'POST',
      data: normalizeGenerationPoemBatchPayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeGenerationPoemPreview(result, normalizedGenealogyId)
  },
  async saveGenerationPoemBatch(genealogyId, payload, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('字辈批量保存需要真实服务，当前本地预览不会伪造保存成功')
      error.code = 'REMOTE_WRITE_REQUIRED'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/generation-poems/batch/save`,
      method: 'POST',
      data: normalizeGenerationPoemBatchPayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async createGenerationPoem(genealogyId, payload, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return writeRemoteObject(`/genealogy/app/genealogies/${id}/generation-poems`, 'POST', normalizeGenerationPoemWritePayload(payload), '字辈', requestOptions)
  },
  async updateGenerationPoem(genealogyId, poemId, payload, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedPoemId = normalizeResourcePathId(poemId, '字辈标识')
    return writeRemoteObject(`/genealogy/app/genealogies/${id}/generation-poems/${normalizedPoemId}`, 'PUT', normalizeGenerationPoemWritePayload(payload), '字辈', requestOptions)
  },
  async getLineagePersons(genealogyId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${id}/lineage/persons`, '世系人物', requestOptions)
  },
  async createPerson(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      return requestStrict({
        url: `/genealogy/app/genealogies/${normalizedGenealogyId}/lineage/persons`,
        method: 'POST',
        data: normalizeLineageWritePayload(payload)
      }, {
        requestController: requireLineageWriteRequestController(requestOptions)
      })
    }
    const error = new Error('人物创建接口在本地预览模式不可用，当前内容不会保存')
    error.code = 'WRITE_UNAVAILABLE'
    throw error
  },
  async createRelatedPerson(genealogyId, personId, relationType, payload, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('人物关系写入接口在本地预览模式不可用，当前内容不会保存')
      error.code = 'WRITE_UNAVAILABLE'
      throw error
    }
    const relationPath = lineageRelationPath[relationType]
    if (!relationPath) throw new TypeError('人物关系类型不属于当前合同')
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedPersonId = normalizeLineagePersonIdentity(personId, '人物标识')
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/lineage/persons/${normalizedPersonId}/${relationPath}`,
      method: 'POST',
      data: normalizeLineageWritePayload(payload)
    }, {
      requestController: requireLineageWriteRequestController(requestOptions)
    })
  },
  async updatePerson(genealogyId, personId, payload, requestOptions = {}) {
    if (!hasRemoteConfig()) {
      const error = new Error('人物编辑接口在本地预览模式不可用，当前内容不会保存')
      error.code = 'WRITE_UNAVAILABLE'
      throw error
    }
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedPersonId = normalizeLineagePersonIdentity(personId, '人物标识')
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/lineage/persons/${normalizedPersonId}`,
      method: 'PUT',
      data: normalizeLineageWritePayload(payload)
    }, {
      requestController: requireLineageWriteRequestController(requestOptions)
    })
  },
  async deletePerson(genealogyId, personId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedPersonId = normalizeResourcePathId(personId, '人物标识')
    return writeRemoteVoid(`/genealogy/app/genealogies/${id}/lineage/persons/${normalizedPersonId}`, 'DELETE', undefined, '世系人物', requestOptions)
  },
  async getFeeds(genealogyId, requestOptions = {}) {
    const normalizedId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) {
      return normalizeFamilyFeedRows(listFamilyFeedFixtures(normalizedId), normalizedId)
    }
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedId}/feeds`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeFamilyFeedRows(result, normalizedId)
  },
  async getFeedDetail(genealogyId, feedId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeFeedCommentId(feedId, '动态标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('动态详情需要真实读取服务，当前本地预览不会伪造详情', 'REMOTE_READ_REQUIRED')
    }
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/feeds/${normalizedFeedId}`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeFamilyFeed(result, normalizedGenealogyId, normalizedFeedId)
  },
  async updateFeed(genealogyId, feedId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeFeedCommentId(feedId, '动态标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('修改动态需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/feeds/${normalizedFeedId}`,
      method: 'PUT',
      data: normalizeFeedCreatePayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeFamilyFeed(result, normalizedGenealogyId, normalizedFeedId)
  },
  async deleteFeed(genealogyId, feedId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeFeedCommentId(feedId, '动态标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('删除动态需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    }
    await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/feeds/${normalizedFeedId}`,
      method: 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async setFeedLike(genealogyId, feedId, liked, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeFeedCommentId(feedId, '动态标识')
    if (typeof liked !== 'boolean') throw new TypeError('动态点赞状态必须是布尔值')
    if (!hasRemoteConfig()) {
      throw createRequestError('动态点赞需要真实服务，当前本地预览不会伪造操作成功', 'REMOTE_WRITE_REQUIRED')
    }
    await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/feeds/${normalizedFeedId}/likes`,
      method: liked ? 'POST' : 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async createFeed(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      const result = await requestStrict({
        url: `/genealogy/app/genealogies/${normalizedGenealogyId}/feeds`,
        method: 'POST',
        data: normalizeFeedCreatePayload(payload)
      }, {
        requestController: requestOptions.requestController ?? null
      })
      const [feed] = normalizeFamilyFeedRows([result], normalizedGenealogyId)
      return feed
    }
    const error = new Error('动态发布接口尚未接入，当前内容不会保存')
    error.code = 'WRITE_UNAVAILABLE'
    throw error
  },
  async createArticle(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      return requestStrict({
        url: `/genealogy/app/genealogies/${normalizedGenealogyId}/articles`,
        method: 'POST',
        data: normalizeArticleCreatePayload(payload)
      }, {
        requestController: requestOptions.requestController ?? null
      })
    }
    const error = new Error('谱文创建需要真实服务，当前本地预览不会伪造创建成功')
    error.code = 'REMOTE_WRITE_REQUIRED'
    throw error
  },
  async createAlbum(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      return requestStrict({
        url: `/genealogy/app/genealogies/${normalizedGenealogyId}/albums`,
        method: 'POST',
        data: normalizeAlbumCreatePayload(payload)
      }, {
        requestController: requestOptions.requestController ?? null
      })
    }
    const error = new Error('相册创建需要真实服务，当前本地预览不会伪造创建成功')
    error.code = 'REMOTE_WRITE_REQUIRED'
    throw error
  },
  async updateAlbum(genealogyId, albumId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedAlbumId = normalizeFeedCommentId(albumId, '相册标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('修改相册需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/albums/${normalizedAlbumId}`,
      method: 'PUT',
      data: normalizeAlbumCreatePayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async deleteAlbum(genealogyId, albumId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedAlbumId = normalizeFeedCommentId(albumId, '相册标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('删除相册需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    }
    await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/albums/${normalizedAlbumId}`,
      method: 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async createAlbumPhoto(genealogyId, albumId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedAlbumId = normalizeFeedCommentId(albumId, '相册标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('上传相册照片需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/albums/${normalizedAlbumId}/photos`,
      method: 'POST',
      data: normalizeAlbumPhotoCreatePayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async deleteAlbumPhoto(genealogyId, albumId, photoId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedAlbumId = normalizeFeedCommentId(albumId, '相册标识')
    const normalizedPhotoId = normalizeFeedCommentId(photoId, '照片标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('删除相册照片需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    }
    await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/albums/${normalizedAlbumId}/photos/${normalizedPhotoId}`,
      method: 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async createCeremony(genealogyId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) {
      throw createRequestError('创建礼仪活动需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies`,
      method: 'POST',
      data: normalizeCeremonyPayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async updateCeremony(genealogyId, ceremonyId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('修改礼仪活动需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}`,
      method: 'PUT',
      data: normalizeCeremonyPayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async deleteCeremony(genealogyId, ceremonyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('删除礼仪活动需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    }
    await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}`,
      method: 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async createCeremonyGift(genealogyId, ceremonyId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('新增礼仪献礼需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}/gifts`,
      method: 'POST',
      data: normalizeCeremonyGiftPayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async deleteCeremonyGift(genealogyId, ceremonyId, giftId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    const normalizedGiftId = normalizeFeedCommentId(giftId, '献礼标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('删除礼仪献礼需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    }
    await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}/gifts/${normalizedGiftId}`,
      method: 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async createRelativeRecord(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      return requestStrict({
        url: `/genealogy/app/genealogies/${normalizedGenealogyId}/relative-records`,
        method: 'POST',
        data: normalizeRelativeRecordCreatePayload(payload)
      }, {
        requestController: requestOptions.requestController ?? null
      })
    }
    const error = new Error('亲友往来创建需要真实服务，当前本地预览不会伪造创建成功')
    error.code = 'REMOTE_WRITE_REQUIRED'
    throw error
  },
  async createGrowthRecord(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      return requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/growth-records`, method: 'POST', data: normalizeGrowthRecordCreatePayload(payload) }, { requestController: requestOptions.requestController ?? null })
    }
    const error = new Error('成长记录创建需要真实服务，当前本地预览不会伪造创建成功')
    error.code = 'REMOTE_WRITE_REQUIRED'
    throw error
  },
  async createMemo(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      return requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/memos`, method: 'POST', data: normalizeMemoCreatePayload(payload) }, { requestController: requestOptions.requestController ?? null })
    }
    const error = new Error('备忘创建需要真实服务，当前本地预览不会伪造创建成功')
    error.code = 'REMOTE_WRITE_REQUIRED'
    throw error
  },
  async createMeritRecord(genealogyId, payload, requestOptions = {}) {
    if (hasRemoteConfig()) {
      const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
      return requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/merit-records`, method: 'POST', data: normalizeMeritRecordCreatePayload(payload) }, { requestController: requestOptions.requestController ?? null })
    }
    const error = new Error('功德记录创建需要真实服务，当前本地预览不会伪造创建成功')
    error.code = 'REMOTE_WRITE_REQUIRED'
    throw error
  },
  async updateGrowthRecord(genealogyId, recordId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedRecordId = normalizeResourcePathId(recordId, '成长记录标识')
    if (!hasRemoteConfig()) throw createRequestError('修改成长记录需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    return requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/growth-records/${normalizedRecordId}`, method: 'PUT', data: normalizeGrowthRecordCreatePayload(payload) }, { requestController: requestOptions.requestController ?? null })
  },
  async deleteGrowthRecord(genealogyId, recordId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedRecordId = normalizeResourcePathId(recordId, '成长记录标识')
    if (!hasRemoteConfig()) throw createRequestError('删除成长记录需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    await requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/growth-records/${normalizedRecordId}`, method: 'DELETE' }, { requireData: false, requestController: requestOptions.requestController ?? null })
    return null
  },
  async updateMemo(genealogyId, memoId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedMemoId = normalizeResourcePathId(memoId, '备忘标识')
    if (!hasRemoteConfig()) throw createRequestError('修改备忘需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    return requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/memos/${normalizedMemoId}`, method: 'PUT', data: normalizeMemoCreatePayload(payload) }, { requestController: requestOptions.requestController ?? null })
  },
  async deleteMemo(genealogyId, memoId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedMemoId = normalizeResourcePathId(memoId, '备忘标识')
    if (!hasRemoteConfig()) throw createRequestError('删除备忘需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    await requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/memos/${normalizedMemoId}`, method: 'DELETE' }, { requireData: false, requestController: requestOptions.requestController ?? null })
    return null
  },
  async updateRelativeRecord(genealogyId, relativeId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedRelativeId = normalizeResourcePathId(relativeId, '亲友记录标识')
    if (!hasRemoteConfig()) throw createRequestError('修改亲友记录需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    return requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/relative-records/${normalizedRelativeId}`, method: 'PUT', data: normalizeRelativeRecordCreatePayload(payload) }, { requestController: requestOptions.requestController ?? null })
  },
  async deleteRelativeRecord(genealogyId, relativeId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedRelativeId = normalizeResourcePathId(relativeId, '亲友记录标识')
    if (!hasRemoteConfig()) throw createRequestError('删除亲友记录需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    await requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/relative-records/${normalizedRelativeId}`, method: 'DELETE' }, { requireData: false, requestController: requestOptions.requestController ?? null })
    return null
  },
  async deleteMeritRecord(genealogyId, meritId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedMeritId = normalizeResourcePathId(meritId, '功德记录标识')
    if (!hasRemoteConfig()) throw createRequestError('删除功德记录需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    await requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/merit-records/${normalizedMeritId}`, method: 'DELETE' }, { requireData: false, requestController: requestOptions.requestController ?? null })
    return null
  },
  async getArticles(genealogyId, requestOptions = {}) {
    const normalizedId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) {
      return normalizeFamilyArticleRows(listFamilyArticleFixtures(normalizedId), normalizedId)
    }
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedId}/articles`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeFamilyArticleRows(result, normalizedId)
  },
  async getArticleDetail(genealogyId, articleId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedArticleId = normalizeFeedCommentId(articleId, '谱文标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('谱文详情需要真实读取服务，当前本地预览不会伪造详情', 'REMOTE_READ_REQUIRED')
    }
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/articles/${normalizedArticleId}`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeFamilyArticle(result, normalizedGenealogyId, normalizedArticleId)
  },
  async updateArticle(genealogyId, articleId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedArticleId = normalizeFeedCommentId(articleId, '谱文标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('修改谱文需要真实服务，当前本地预览不会伪造保存成功', 'REMOTE_WRITE_REQUIRED')
    }
    return requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/articles/${normalizedArticleId}`,
      method: 'PUT',
      data: normalizeArticleCreatePayload(payload)
    }, {
      requestController: requestOptions.requestController ?? null
    })
  },
  async deleteArticle(genealogyId, articleId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedArticleId = normalizeFeedCommentId(articleId, '谱文标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('删除谱文需要真实服务，当前本地预览不会伪造删除成功', 'REMOTE_WRITE_REQUIRED')
    }
    await requestStrict({
      url: `/genealogy/app/genealogies/${normalizedGenealogyId}/articles/${normalizedArticleId}`,
      method: 'DELETE'
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async getAlbums(genealogyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) return listFamilyAlbumFixtures(normalizedGenealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/albums`, '相册列表', requestOptions)
  },
  async getAlbumPhotos(genealogyId, albumId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedAlbumId = normalizeFeedCommentId(albumId, '相册标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('相册照片需要真实读取服务，当前本地预览不会伪造照片列表', 'REMOTE_READ_REQUIRED')
    }
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/albums/${normalizedAlbumId}/photos`, '相册照片', requestOptions)
  },
  async getCeremonies(genealogyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) return listCeremonyFixtures(normalizedGenealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies`, '礼仪活动', requestOptions)
  },
  async replaceCeremonyInvitees(genealogyId, ceremonyId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    return writeRemoteObject(
      `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}/invitees`,
      'PUT',
      normalizeCeremonyInviteePayload(payload),
      '活动受邀人',
      requestOptions
    )
  },
  async getCeremonyInvitations(genealogyId, ceremonyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    return readRemoteList(
      `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}/invitations`,
      '活动邀请名单',
      requestOptions
    )
  },
  async respondToCeremonyInvitation(genealogyId, ceremonyId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    return writeRemoteObject(
      `/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}/invitations/me`,
      'PUT',
      normalizeCeremonyInvitationResponsePayload(payload),
      '活动邀请响应',
      requestOptions
    )
  },
  async getMyCeremonyInvitations(requestOptions = {}) {
    return readRemoteList('/genealogy/app/genealogies/ceremony-invitations/mine', '我的活动邀请', requestOptions)
  },
  async getCeremonyDetail(genealogyId, ceremonyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('礼仪详情需要真实读取服务，当前本地预览不会伪造详情', 'REMOTE_READ_REQUIRED')
    }
    return readRemoteObject(`/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}`, '礼仪活动详情', requestOptions)
  },
  async getCeremonyGifts(genealogyId, ceremonyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedCeremonyId = normalizeFeedCommentId(ceremonyId, '礼仪活动标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('礼仪献礼需要真实读取服务，当前本地预览不会伪造列表', 'REMOTE_READ_REQUIRED')
    }
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/ceremonies/${normalizedCeremonyId}/gifts`, '礼仪献礼', requestOptions)
  },
  async getGrowthRecords(genealogyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) return listGrowthRecordFixtures(normalizedGenealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/growth-records`, '成长记录', requestOptions)
  },
  async getGrowthRecordDetail(genealogyId, recordId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedRecordId = normalizeResourcePathId(recordId, '成长记录标识')
    if (!hasRemoteConfig()) throw createRequestError('成长记录详情需要真实读取服务，当前本地预览不会伪造详情', 'REMOTE_READ_REQUIRED')
    return readRemoteObject(`/genealogy/app/genealogies/${normalizedGenealogyId}/growth-records/${normalizedRecordId}`, '成长记录详情', requestOptions)
  },
  async getMemos(genealogyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) throw createRequestError('备忘列表需要真实读取服务，当前本地预览不会伪造列表', 'REMOTE_READ_REQUIRED')
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/memos`, '备忘录', requestOptions)
  },
  async getMemoDetail(genealogyId, memoId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedMemoId = normalizeResourcePathId(memoId, '备忘标识')
    if (!hasRemoteConfig()) throw createRequestError('备忘详情需要真实读取服务，当前本地预览不会伪造详情', 'REMOTE_READ_REQUIRED')
    return readRemoteObject(`/genealogy/app/genealogies/${normalizedGenealogyId}/memos/${normalizedMemoId}`, '备忘录详情', requestOptions)
  },
  async getRelativeRecords(genealogyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) throw createRequestError('亲友记录需要真实读取服务，当前本地预览不会伪造列表', 'REMOTE_READ_REQUIRED')
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/relative-records`, '亲友往来', requestOptions)
  },
  async getRelativeRecordDetail(genealogyId, relativeId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedRelativeId = normalizeResourcePathId(relativeId, '亲友记录标识')
    if (!hasRemoteConfig()) throw createRequestError('亲友记录详情需要真实读取服务，当前本地预览不会伪造详情', 'REMOTE_READ_REQUIRED')
    return readRemoteObject(`/genealogy/app/genealogies/${normalizedGenealogyId}/relative-records/${normalizedRelativeId}`, '亲友往来详情', requestOptions)
  },
  async getMeritRecords(genealogyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) throw createRequestError('功德记录需要真实读取服务，当前本地预览不会伪造列表', 'REMOTE_READ_REQUIRED')
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/merit-records`, '功德记录', requestOptions)
  },
  async getFeedback(requestOptions = {}) {
    return readRemoteList('/genealogy/app/feedback', '我的反馈', requestOptions)
  },
  async getVideos(genealogyId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${id}/videos`, '家族视频', requestOptions)
  },
  async getVideoDetail(genealogyId, videoId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedVideoId = normalizeResourcePathId(videoId, '视频标识')
    return readRemoteObject(`/genealogy/app/genealogies/${id}/videos/${normalizedVideoId}`, '家族视频详情', requestOptions)
  },
  async createVideo(genealogyId, payload, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return writeRemoteObject(`/genealogy/app/genealogies/${id}/videos`, 'POST', normalizeVideoPayload(payload), '家族视频', requestOptions)
  },
  async updateVideo(genealogyId, videoId, payload, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedVideoId = normalizeResourcePathId(videoId, '视频标识')
    return writeRemoteObject(`/genealogy/app/genealogies/${id}/videos/${normalizedVideoId}`, 'PUT', normalizeVideoPayload(payload), '家族视频', requestOptions)
  },
  async deleteVideo(genealogyId, videoId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedVideoId = normalizeResourcePathId(videoId, '视频标识')
    return writeRemoteVoid(`/genealogy/app/genealogies/${id}/videos/${normalizedVideoId}`, 'DELETE', undefined, '家族视频', requestOptions)
  },
  async getArticleCategories(genealogyId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${id}/article-categories`, '谱文分类', requestOptions)
  },
  async getFeedPage(genealogyId, { pageNum = 1, pageSize = 20 } = {}, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    if (!Number.isSafeInteger(pageNum) || pageNum < 1 || !Number.isSafeInteger(pageSize) || pageSize < 1) throw new TypeError('动态分页参数无效')
    requireRemoteResource('家族动态', '读取')
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${id}/feeds/page`,
      method: 'GET',
      data: { pageNum, pageSize }
    }, { requireData: false, requestController: requestOptions.requestController ?? null })
    if (!result || typeof result !== 'object' || !Array.isArray(result.rows) || !Number.isSafeInteger(result.total)) {
      throw createRequestError('动态分页响应无效', 'PAGE_RESPONSE_INVALID')
    }
    return { rows: normalizeFamilyFeedRows(result.rows, id), total: result.total }
  },
  async getFeedCommentPage(genealogyId, feedId, { pageNum = 1, pageSize = 20 } = {}, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeResourcePathId(feedId, '动态标识')
    if (!Number.isSafeInteger(pageNum) || pageNum < 1 || !Number.isSafeInteger(pageSize) || pageSize < 1) throw new TypeError('评论分页参数无效')
    requireRemoteResource('动态评论', '读取')
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${id}/feeds/${normalizedFeedId}/comments/page`,
      method: 'GET',
      data: { pageNum, pageSize }
    }, { requireData: false, requestController: requestOptions.requestController ?? null })
    if (!result || typeof result !== 'object' || !Array.isArray(result.rows) || !Number.isSafeInteger(result.total)) {
      throw createRequestError('动态评论分页响应无效', 'PAGE_RESPONSE_INVALID')
    }
    return { rows: normalizeFeedComments(result.rows, id, normalizedFeedId), total: result.total }
  },
  async getCommentReplies(genealogyId, feedId, commentId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeResourcePathId(feedId, '动态标识')
    const normalizedCommentId = normalizeResourcePathId(commentId, '评论标识')
    return readRemoteList(`/genealogy/app/genealogies/${id}/feeds/${normalizedFeedId}/comments/${normalizedCommentId}/replies`, '评论回复', requestOptions)
  },
  async getCommentReplyPage(genealogyId, feedId, commentId, { pageNum = 1, pageSize = 20 } = {}, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeResourcePathId(feedId, '动态标识')
    const normalizedCommentId = normalizeResourcePathId(commentId, '评论标识')
    if (!Number.isSafeInteger(pageNum) || pageNum < 1 || !Number.isSafeInteger(pageSize) || pageSize < 1) throw new TypeError('回复分页参数无效')
    requireRemoteResource('评论回复', '读取')
    const result = await requestStrict({
      url: `/genealogy/app/genealogies/${id}/feeds/${normalizedFeedId}/comments/${normalizedCommentId}/replies/page`,
      method: 'GET',
      data: { pageNum, pageSize }
    }, { requireData: false, requestController: requestOptions.requestController ?? null })
    if (!result || typeof result !== 'object' || !Array.isArray(result.rows) || !Number.isSafeInteger(result.total)) {
      throw createRequestError('评论回复分页响应无效', 'PAGE_RESPONSE_INVALID')
    }
    return { rows: normalizeFeedComments(result.rows, id, normalizedFeedId), total: result.total }
  },
  async deleteFeedComment(genealogyId, feedId, commentId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const normalizedFeedId = normalizeResourcePathId(feedId, '动态标识')
    const normalizedCommentId = normalizeResourcePathId(commentId, '评论标识')
    return writeRemoteVoid(`/genealogy/app/genealogies/${id}/feeds/${normalizedFeedId}/comments/${normalizedCommentId}`, 'DELETE', undefined, '动态评论', requestOptions)
  },
  async changePhone(payload, requestOptions = {}) {
    requireRemoteAuth()
    await requestStrict({
      url: '/genealogy/app/auth/phone',
      method: 'PUT',
      data: normalizePhoneChangePayload(payload)
    }, {
      requireData: false,
      requestController: requestOptions.requestController ?? null
    })
    return null
  },
  async getHelpArticles(requestOptions = {}) {
    return readRemoteList('/genealogy/app/help-articles', '帮助文章', requestOptions)
  },
  async getHelpArticle(helpId, requestOptions = {}) {
    const id = normalizeResourcePathId(helpId, '帮助文章标识')
    return readRemoteObject(`/genealogy/app/help-articles/${id}`, '帮助文章详情', requestOptions)
  },
  async getPromotions(requestOptions = {}) {
    return readRemoteList('/genealogy/app/promotions', '应用推广', requestOptions)
  },
  async getVipPackages(requestOptions = {}) {
    return readRemoteList('/genealogy/app/vip/packages', 'VIP 套餐', requestOptions)
  },
  async getVipOrders(requestOptions = {}) {
    return readRemoteList('/genealogy/app/vip/orders', 'VIP 订单', requestOptions)
  },
  async createVipOrder(payload, requestOptions = {}) {
    return writeRemoteObject('/genealogy/app/vip/orders', 'POST', normalizeVipOrderPayload(payload), 'VIP 订单', requestOptions)
  },
  async getGenealogyOptions(requestOptions = {}) {
    return readRemoteList('/genealogy/app/genealogies/options', '家谱选项', requestOptions)
  },
  async getMembers(genealogyId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${id}/members`, '家谱成员', requestOptions)
  },
  async getMemberOptions(genealogyId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${id}/members/options`, '成员选项', requestOptions)
  },
  async updateMember(genealogyId, memberId, payload, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const memberIdValue = normalizeResourcePathId(memberId, '成员标识')
    return writeRemoteObject(`/genealogy/app/genealogies/${id}/members/${memberIdValue}`, 'PUT', normalizeMemberUpdatePayload(payload), '家谱成员', requestOptions)
  },
  async removeMember(genealogyId, memberId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    const memberIdValue = normalizeResourcePathId(memberId, '成员标识')
    return writeRemoteVoid(`/genealogy/app/genealogies/${id}/members/${memberIdValue}`, 'DELETE', undefined, '家谱成员', requestOptions)
  },
  async leaveGenealogy(genealogyId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return writeRemoteVoid(`/genealogy/app/genealogies/${id}/members/me`, 'DELETE', undefined, '退出家谱', requestOptions)
  },
  async transferGenealogyOwner(genealogyId, targetMemberId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return writeRemoteObject(`/genealogy/app/genealogies/${id}/members/owner-transfer`, 'PUT', {
      targetMemberId: Number(normalizeResourcePathId(targetMemberId, '目标成员标识'))
    }, '家谱所有者转让', requestOptions)
  },
  async getLineagePersonOptions(genealogyId, requestOptions = {}) {
    const id = normalizeGenealogyPathId(genealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${id}/lineage/persons/options`, '世系人物选项', requestOptions)
  },
  async getSiteArticles(payload = {}, requestOptions = {}) {
    const result = await requestStrict({
      url: '/genealogy/app/site/articles',
      method: 'GET',
      data: normalizeSiteArticleQuery(payload)
    }, {
      authenticated: false,
      requestController: requestOptions.requestController ?? null
    })
    if (!Array.isArray(result)) {
      throw createRequestError('官网文章列表响应不是数组', 'SITE_ARTICLE_LIST_RESPONSE_INVALID')
    }
    return result
  },
  async getSitePage(pageKey, requestOptions = {}) {
    const result = await requestStrict({
      url: `/genealogy/app/site/pages/${encodeURIComponent(normalizeSitePageKey(pageKey))}`,
      method: 'GET'
    }, {
      authenticated: false,
      requestController: requestOptions.requestController ?? null
    })
    if (!result || typeof result !== 'object' || Array.isArray(result)) {
      throw createRequestError('官网单页响应不是对象', 'SITE_PAGE_RESPONSE_INVALID')
    }
    return result
  },
  async getNotifications(requestOptions = {}) {
    if (!hasRemoteConfig()) return listNotificationFixtures()
    return readRemoteList('/genealogy/app/notifications', '消息通知', requestOptions)
  },
  async getNotificationDetail(notificationId, requestOptions = {}) {
    const normalizedNotificationId = normalizeResourcePathId(notificationId, '通知标识')
    if (!hasRemoteConfig()) {
      throw createRequestError('通知详情需要真实服务读取，当前本地预览不伪造通知正文', 'REMOTE_READ_REQUIRED')
    }
    const result = await requestStrict({
      url: `/genealogy/app/notifications/${normalizedNotificationId}`,
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    return normalizeNotificationDetail(result, normalizedNotificationId)
  },
  async getUnreadNotificationCount(requestOptions = {}) {
    requireRemoteResource('未读通知数量', '读取')
    const value = await requestStrict({
      url: '/genealogy/app/notifications/unread-count',
      method: 'GET'
    }, {
      requestController: requestOptions.requestController ?? null
    })
    if (!Number.isSafeInteger(value) || value < 0) {
      throw createRequestError('未读通知数量响应无效', 'NOTIFICATION_COUNT_RESPONSE_INVALID')
    }
    return value
  },
  async markNotificationRead(notificationId, requestOptions = {}) {
    const normalizedNotificationId = normalizeResourcePathId(notificationId, '通知标识')
    if (hasRemoteConfig()) {
      await requestStrict({ url: `/genealogy/app/notifications/${normalizedNotificationId}/read`, method: 'POST' }, { requireData: false, requestController: requestOptions.requestController ?? null })
      return null
    }
    const notification = notifications.find((item) => String(item.id) === normalizedNotificationId)
    if (notification) notification.unread = false
    return { success: true }
  },
  async markAllNotificationsRead(requestOptions = {}) {
    if (hasRemoteConfig()) {
      await requestStrict({ url: '/genealogy/app/notifications/read-all', method: 'POST' }, { requireData: false, requestController: requestOptions.requestController ?? null })
      return null
    }
    notifications.forEach((item) => { item.unread = false })
    return { success: true }
  },
  async getPublicGenealogies(requestOptions = {}) {
    if (!hasRemoteConfig()) return publicGenealogies
    return readRemoteList('/genealogy/app/genealogies/public', '公开家谱', requestOptions)
  },
  async applyToJoin(genealogyId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const data = normalizeJoinApplicationPayload(payload)
    if (hasRemoteConfig()) return requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/join-applies`, method: 'POST', data }, { requestController: requestOptions.requestController ?? null })
    joinApplications.unshift({
      id: String(Date.now()),
      genealogyId: normalizedGenealogyId,
      name: payload.applicantName || currentUser.name,
      phone: payload.phone || currentUser.phone,
      relation: payload.relationDesc || '关系待补充',
      reason: payload.applyReason || '',
      appliedAt: '刚刚',
      status: 'PENDING'
    })
    return { success: true }
  },
  async getMyJoinApplications(requestOptions = {}) {
    if (!hasRemoteConfig()) return joinApplications
    return readRemoteList('/genealogy/app/genealogies/join-applies/mine', '我的加入申请', requestOptions)
  },
  async withdrawJoinApplication(applicationId, requestOptions = {}) {
    const normalizedApplicationId = normalizeResourcePathId(applicationId, '加入申请标识')
    if (!hasRemoteConfig()) throw createRequestError('撤销加入申请需要真实服务，当前本地预览不会伪造撤销成功', 'REMOTE_WRITE_REQUIRED')
    await requestStrict({ url: `/genealogy/app/genealogies/join-applies/${normalizedApplicationId}`, method: 'DELETE' }, { requireData: false, requestController: requestOptions.requestController ?? null })
    return null
  },
  async getPendingApplications(genealogyId, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    if (!hasRemoteConfig()) return joinApplications.filter((item) => String(item.genealogyId || 1001) === normalizedGenealogyId)
    return readRemoteList(`/genealogy/app/genealogies/${normalizedGenealogyId}/join-applies/pending`, '待审核申请', requestOptions)
  },
  async auditApplication(genealogyId, applicationId, payload, requestOptions = {}) {
    const normalizedGenealogyId = normalizeGenealogyPathId(genealogyId)
    const normalizedApplicationId = normalizeResourcePathId(applicationId, '加入申请标识')
    const data = normalizeJoinAuditPayload(payload)
    if (hasRemoteConfig()) {
      await requestStrict({ url: `/genealogy/app/genealogies/${normalizedGenealogyId}/join-applies/${normalizedApplicationId}/audit`, method: 'PUT', data }, { requireData: false, requestController: requestOptions.requestController ?? null })
      return null
    }
    const application = joinApplications.find((item) => String(item.id) === normalizedApplicationId)
    if (application) Object.assign(application, data)
    return { success: true }
  }
}