py_wisharetec_toolkit 3.0.2__py3-none-any.whl

py_wisharetec_toolkit/shanshu/client.py

@@ -0,0 +1,2218 @@
+#!/usr/bin/env python3
+# -*- coding: UTF-8 -*-
+
+"""Shanshu HTTP 客户端。
+
+基于 httpx 实现，使用 pydantic 对初始化参数进行验证，
+登录返回使用 ``models`` 中的 pydantic 模型处理。
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+from pydantic import BaseModel, Field, field_validator
+
+from .auth import LOGIN_PATH, ShanshuMemoryTokenCache, ShanshuTokenCache, cache_key, md5
+from .models import (
+    ShanshuApprovalDetailRecord,
+    ShanshuApprovalPageResponse,
+    ShanshuArchivePageResponse,
+    ShanshuBuildingPageResponse,
+    ShanshuCarManagePageResponse,
+    ShanshuCommunityPageResponse,
+    ShanshuLoginResponse,
+    ShanshuMallOrderPageResponse,
+    ShanshuOwnerDetailRecord,
+    ShanshuPageQueryParams,
+    ShanshuParkingPageResponse,
+    ShanshuPropertyPageResponse,
+    ShanshuResidentPageResponse,
+    ShanshuServiceOrderPageResponse,
+    ShanshuLoginError,
+    ShanshuWorkOrderPageResponse,
+    ShanshuYardArchivePageResponse,
+)
+
+
+DEFAULT_BASE_URL = "https://saas.wisharetec.com/"
+
+COMMUNITY_FRONT_PAGE_PATH = "api/space/community/v2/frontPage"
+PROPERTY_PAGE_PATH = "api/space/property/propertyPage"
+YARD_ARCHIVE_PAGE_PATH = "api/space/space/yardArchivePage"
+BUILDING_PAGE_PATH = "api/space/property/getSpaceBuildingPage"
+RESIDENT_PAGE_PATH = "api/user/residentInfo/getResidentPage"
+ARCHIVE_PAGE_PATH = "api/space/archive/examine/page"
+CAR_MANAGE_PAGE_PATH = "api/space/carManage/pageCarManage"
+PARKING_PAGE_PATH = "api/space/parking/parkingPage"
+WORK_ORDER_PAGE_PATH = "api/woreport/task/query/page"
+MALL_ORDER_PAGE_PATH = "api/retailmall/order/pageFront"
+SERVICE_ORDER_PAGE_PATH = "api/houseserve/order/pageFront"
+OWNER_DETAIL_PATH = "api/space/archive/archive/detailSensitive"
+APPROVAL_PAGE_PATH = "api/bpm/process/approval"
+APPROVAL_DETAIL_PATH = "api/bpm/process/progress/{instance_id}/node_433279443693"
+
+
+class ShanshuClientConfig(BaseModel):
+    """Shanshu 客户端配置，所有字段均通过 pydantic 校验。"""
+
+    base_url: str = Field(default=DEFAULT_BASE_URL)
+    account: str = Field(min_length=1)
+    password: str = Field(min_length=1)
+
+    @field_validator("base_url")
+    @classmethod
+    def _validate_base_url(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("base_url 不能为空")
+        v = v.strip()
+        if not v.endswith("/"):
+            v = v + "/"
+        return v
+
+    @field_validator("account", "password")
+    @classmethod
+    def _validate_not_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("字段不能为空")
+        return v.strip()
+
+
+class ShanshuClient:
+    """基于 httpx 的 Shanshu API 客户端。
+
+    参数
+    ----------
+    base_url : str, optional
+        API 基础地址，默认 ``https://saas.wisharetec.com/``。
+    account : str
+        账号，用于请求认证头。
+    password : str
+        密码，用于请求认证头。
+    config : ShanshuClientConfig, optional
+        已构建的配置对象，提供后则 ``base_url``/``account``/``password`` 被忽略。
+    timeout : float, optional
+        请求超时时间（秒），默认 30.0。
+    token_cache : ShanshuTokenCache, optional
+        Token 缓存实现，未提供则使用进程内内存缓存。
+    **kwargs : dict
+        透传给 ``httpx.Client`` 的其他参数。
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        account: str = "",
+        password: str = "",
+        *,
+        config: ShanshuClientConfig | None = None,
+        timeout: float = 30.0,
+        token_cache: ShanshuTokenCache | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if config is not None:
+            self.config = config
+        else:
+            self.config = ShanshuClientConfig(
+                base_url=base_url,
+                account=account,
+                password=password,
+            )
+
+        self._token_cache: ShanshuTokenCache = token_cache or ShanshuMemoryTokenCache()
+        self._token: str | None = None
+
+        self._client = httpx.Client(
+            base_url=self.config.base_url,
+            timeout=timeout,
+            **kwargs,
+        )
+
+        self._client.headers.update(
+            {
+                "X-Shanshu-Account": self.config.account,
+                "X-Shanshu-Password": self.config.password,
+            }
+        )
+
+    @property
+    def base_url(self) -> str:
+        """客户端基础地址。"""
+        return self.config.base_url
+
+    @property
+    def account(self) -> str:
+        """客户端账号。"""
+        return self.config.account
+
+    @property
+    def token(self) -> str | None:
+        """当前缓存的 Token（优先返回实例内存，其次读取缓存后端）。"""
+        if self._token is not None:
+            return self._token
+        key = cache_key(self.config.account)
+        return self._token_cache.get(key)
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        data: Any = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """发起一次 HTTP 请求。"""
+        return self._client.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json,
+            data=data,
+            headers=headers,
+            **kwargs,
+        )
+
+    def get(self, url: str, **kwargs: Any) -> httpx.Response:
+        """发起 GET 请求。"""
+        return self.request("GET", url, **kwargs)
+
+    def post(self, url: str, **kwargs: Any) -> httpx.Response:
+        """发起 POST 请求。"""
+        return self.request("POST", url, **kwargs)
+
+    def login(
+        self,
+        account: str,
+        password: str,
+        *,
+        password_md5: bool = True,
+        token_cache: ShanshuTokenCache | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuLoginResponse:
+        """调用 /api/user/loginInteractive 进行交互式登录。
+
+        参数
+        ----------
+        account : str
+            账号。
+        password : str
+            明文密码，``password_md5=True`` 时会对其做 MD5 后再发送。
+        password_md5 : bool, default True
+            是否对密码做 MD5 加密，默认开启。
+        token_cache : ShanshuTokenCache, optional
+            临时覆盖本次登录使用的缓存实现，未提供则使用客户端默认缓存。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuLoginResponse
+            登录接口的解析后响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc``。
+        - 返回体若不包含 ``code`` 字段，视为登录成功。
+        - 成功后从响应 headers 中提取 ``authorization`` 值，按
+          ``py_wisharetec_toolkit:shanshu:authorization_token:{account}`` 缓存。
+        """
+        cache = token_cache or self._token_cache
+        key = cache_key(account)
+
+        headers = {"client": "co-pc"}
+        if extra_headers:
+            headers.update(extra_headers)
+
+        payload = {
+            "account": account,
+            "password": md5(password) if password_md5 else password,
+        }
+
+        resp = self._client.post(LOGIN_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        login_resp = ShanshuLoginResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        # 登录成功：从响应 headers 提取 authorization token 并按 account 缓存
+        token = resp.headers.get("authorization")
+        if token:
+            cache.set(key, token)
+            self._token = token
+
+        return login_resp
+
+    def query_community_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuCommunityPageResponse:
+        """调用 /api/space/community/v2/frontPage 查询园区档案列表。
+
+        基础档案 -> 园区档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuCommunityPageResponse
+            园区档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(COMMUNITY_FRONT_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        community_resp = ShanshuCommunityPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return community_resp
+
+    def query_property_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuPropertyPageResponse:
+        """调用 /api/space/property/propertyPage 查询房产档案列表。
+
+        基础档案 -> 房产档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuPropertyPageResponse
+            房产档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(PROPERTY_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        property_resp = ShanshuPropertyPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return property_resp
+
+    def query_building_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuBuildingPageResponse:
+        """调用 /api/space/property/getSpaceBuildingPage 查询楼幢档案列表。
+
+        基础档案 -> 楼幢档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuBuildingPageResponse
+            楼幢档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(BUILDING_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        building_resp = ShanshuBuildingPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return building_resp
+
+    def query_resident_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuResidentPageResponse:
+        """调用 /api/user/residentInfo/getResidentPage 查询用户/居民档案列表。
+
+        用户档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuResidentPageResponse
+            用户/居民档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(RESIDENT_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        resident_resp = ShanshuResidentPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return resident_resp
+
+    def query_car_manage_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuCarManagePageResponse:
+        """调用 /api/space/carManage/pageCarManage 查询车辆档案列表。
+
+        车辆管理 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuCarManagePageResponse
+            车辆档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(CAR_MANAGE_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        car_manage_resp = ShanshuCarManagePageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return car_manage_resp
+
+    def query_parking_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuParkingPageResponse:
+        """调用 /api/space/parking/parkingPage 查询车位档案列表。
+
+        车位档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuParkingPageResponse
+            车位档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(PARKING_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        parking_resp = ShanshuParkingPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return parking_resp
+
+    def query_work_order_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuWorkOrderPageResponse:
+        """调用 /api/woreport/task/query/page 查询工单列表。
+
+        工单管理 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuWorkOrderPageResponse
+            工单分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(WORK_ORDER_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        work_order_resp = ShanshuWorkOrderPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return work_order_resp
+
+    def query_mall_order_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuMallOrderPageResponse:
+        """调用 /api/retailmall/order/pageFront 查询园区商城订单列表。
+
+        商城订单 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuMallOrderPageResponse
+            商城订单分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(MALL_ORDER_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        mall_order_resp = ShanshuMallOrderPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return mall_order_resp
+
+    def query_service_order_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuServiceOrderPageResponse:
+        """调用 /api/houseserve/order/pageFront 查询服务订单列表。
+
+        服务订单 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuServiceOrderPageResponse
+            服务订单分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(SERVICE_ORDER_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        service_order_resp = ShanshuServiceOrderPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return service_order_resp
+
+    def query_approval_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuApprovalPageResponse:
+        """调用 /api/bpm/process/approval 查询审批数据列表。
+
+        审批管理 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuApprovalPageResponse
+            审批数据分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(APPROVAL_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        approval_resp = ShanshuApprovalPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return approval_resp
+
+    def query_approval_detail(
+        self,
+        *,
+        instance_id: str,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuApprovalDetailRecord:
+        """调用 /api/bpm/process/progress/{instance_id}/node_433279443693 查询审批详情。
+
+        这是一个 GET 请求接口，实例 ID 通过 URL 路径传递，节点 ID 固定为 ``node_433279443693``。
+
+        参数
+        ----------
+        instance_id : str
+            流程实例 ID (procInstId)。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuApprovalDetailRecord
+            审批详情响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 GET。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        url = APPROVAL_DETAIL_PATH.format(instance_id=instance_id)
+
+        resp = self._client.get(url, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        approval_detail = ShanshuApprovalDetailRecord.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return approval_detail
+
+    def query_owner_detail(
+        self,
+        *,
+        user_id: str,
+        community_id: str,
+        space_id: str,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuOwnerDetailRecord:
+        """调用 /api/space/archive/archive/detailSensitive 查询业主详情。
+
+        这是一个 GET 请求接口，参数通过 URL 查询字符串传递。
+
+        参数
+        ----------
+        user_id : str
+            用户 ID。
+        community_id : str
+            小区/社区 ID。
+        space_id : str
+            空间 ID（房产/车位等空间 ID）。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuOwnerDetailRecord
+            业主详情响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 GET。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        params: dict[str, str] = {
+            "userId": user_id,
+            "communityId": community_id,
+            "spaceId": space_id,
+        }
+
+        resp = self._client.get(OWNER_DETAIL_PATH, params=params, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        owner_detail = ShanshuOwnerDetailRecord.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return owner_detail
+
+    def query_archive_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuArchivePageResponse:
+        """调用 /api/space/archive/examine/page 查询业主档案列表。
+
+        业主档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuArchivePageResponse
+            业主档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(ARCHIVE_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        archive_resp = ShanshuArchivePageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return archive_resp
+
+    def query_yard_archive_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuYardArchivePageResponse:
+        """调用 /api/space/space/yardArchivePage 查询车场档案列表。
+
+        基础档案 -> 车场档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuYardArchivePageResponse
+            车场档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = self._client.post(YARD_ARCHIVE_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        yard_archive_resp = ShanshuYardArchivePageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return yard_archive_resp
+
+    def close(self) -> None:
+        """关闭底层 httpx 客户端。"""
+        self._client.close()
+
+    def __enter__(self) -> "ShanshuClient":
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+
+__all__ = [
+    "ShanshuClient",
+    "ShanshuClientConfig",
+    "ShanshuLoginError",
+    "DEFAULT_BASE_URL",
+    "COMMUNITY_FRONT_PAGE_PATH",
+    "AsyncShanshuClient",
+    "AsyncShanshuClientConfig",
+]
+
+
+class AsyncShanshuClientConfig(BaseModel):
+    """Shanshu 异步客户端配置，所有字段均通过 pydantic 校验。"""
+
+    base_url: str = Field(default=DEFAULT_BASE_URL)
+    account: str = Field(min_length=1)
+    password: str = Field(min_length=1)
+
+    @field_validator("base_url")
+    @classmethod
+    def _validate_base_url(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("base_url 不能为空")
+        v = v.strip()
+        if not v.endswith("/"):
+            v = v + "/"
+        return v
+
+    @field_validator("account", "password")
+    @classmethod
+    def _validate_not_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("字段不能为空")
+        return v.strip()
+
+
+class AsyncShanshuClient:
+    """基于 httpx.AsyncClient 的 Shanshu 异步 API 客户端。
+
+    参数
+    ----------
+    base_url : str, optional
+        API 基础地址，默认 ``https://saas.wisharetec.com/``。
+    account : str
+        账号，用于请求认证头。
+    password : str
+        密码，用于请求认证头。
+    config : AsyncShanshuClientConfig, optional
+        已构建的配置对象，提供后则 ``base_url``/``account``/``password`` 被忽略。
+    timeout : float, optional
+        请求超时时间（秒），默认 30.0。
+    token_cache : ShanshuTokenCache, optional
+        Token 缓存实现，未提供则使用进程内内存缓存。
+    **kwargs : dict
+        透传给 ``httpx.AsyncClient`` 的其他参数。
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        account: str = "",
+        password: str = "",
+        *,
+        config: AsyncShanshuClientConfig | None = None,
+        timeout: float = 30.0,
+        token_cache: ShanshuTokenCache | None = None,
+        **kwargs: Any,
+    ) -> None:
+        if config is not None:
+            self.config = config
+        else:
+            self.config = AsyncShanshuClientConfig(
+                base_url=base_url,
+                account=account,
+                password=password,
+            )
+
+        self._token_cache: ShanshuTokenCache = token_cache or ShanshuMemoryTokenCache()
+        self._token: str | None = None
+
+        self._client = httpx.AsyncClient(
+            base_url=self.config.base_url,
+            timeout=timeout,
+            **kwargs,
+        )
+
+        self._client.headers.update(
+            {
+                "X-Shanshu-Account": self.config.account,
+                "X-Shanshu-Password": self.config.password,
+            }
+        )
+
+    @property
+    def base_url(self) -> str:
+        """客户端基础地址。"""
+        return self.config.base_url
+
+    @property
+    def account(self) -> str:
+        """客户端账号。"""
+        return self.config.account
+
+    @property
+    def token(self) -> str | None:
+        """当前缓存的 Token（优先返回实例内存，其次读取缓存后端）。"""
+        if self._token is not None:
+            return self._token
+        key = cache_key(self.config.account)
+        return self._token_cache.get(key)
+
+    async def async_request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json: Any = None,
+        data: Any = None,
+        headers: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> httpx.Response:
+        """发起一次异步 HTTP 请求。"""
+        return await self._client.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json,
+            data=data,
+            headers=headers,
+            **kwargs,
+        )
+
+    async def async_get(self, url: str, **kwargs: Any) -> httpx.Response:
+        """发起异步 GET 请求。"""
+        return await self.async_request("GET", url, **kwargs)
+
+    async def async_post(self, url: str, **kwargs: Any) -> httpx.Response:
+        """发起异步 POST 请求。"""
+        return await self.async_request("POST", url, **kwargs)
+
+    async def async_login(
+        self,
+        account: str,
+        password: str,
+        *,
+        password_md5: bool = True,
+        token_cache: ShanshuTokenCache | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuLoginResponse:
+        """调用 /api/user/loginInteractive 进行交互式登录。
+
+        参数
+        ----------
+        account : str
+            账号。
+        password : str
+            明文密码，``password_md5=True`` 时会对其做 MD5 后再发送。
+        password_md5 : bool, default True
+            是否对密码做 MD5 加密，默认开启。
+        token_cache : ShanshuTokenCache, optional
+            临时覆盖本次登录使用的缓存实现，未提供则使用客户端默认缓存。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuLoginResponse
+            登录接口的解析后响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc``。
+        - 返回体若不包含 ``code`` 字段，视为登录成功。
+        - 成功后从响应 headers 中提取 ``authorization`` 值，按
+          ``py_wisharetec_toolkit:shanshu:authorization_token:{account}`` 缓存。
+        """
+        cache = token_cache or self._token_cache
+        key = cache_key(account)
+
+        headers = {"client": "co-pc"}
+        if extra_headers:
+            headers.update(extra_headers)
+
+        payload = {
+            "account": account,
+            "password": md5(password) if password_md5 else password,
+        }
+
+        resp = await self._client.post(LOGIN_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        login_resp = ShanshuLoginResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        # 登录成功：从响应 headers 提取 authorization token 并按 account 缓存
+        token = resp.headers.get("authorization")
+        if token:
+            cache.set(key, token)
+            self._token = token
+
+        return login_resp
+
+    async def async_query_community_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuCommunityPageResponse:
+        """调用 /api/space/community/v2/frontPage 查询园区档案列表。
+
+        基础档案 -> 园区档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuCommunityPageResponse
+            园区档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(COMMUNITY_FRONT_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        community_resp = ShanshuCommunityPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return community_resp
+
+    async def async_query_property_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuPropertyPageResponse:
+        """调用 /api/space/property/propertyPage 查询房产档案列表。
+
+        基础档案 -> 房产档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuPropertyPageResponse
+            房产档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(PROPERTY_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        property_resp = ShanshuPropertyPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return property_resp
+
+    async def async_query_building_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuBuildingPageResponse:
+        """调用 /api/space/property/getSpaceBuildingPage 查询楼幢档案列表。
+
+        基础档案 -> 楼幢档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuBuildingPageResponse
+            楼幢档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(BUILDING_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        building_resp = ShanshuBuildingPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return building_resp
+
+    async def async_query_resident_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuResidentPageResponse:
+        """调用 /api/user/residentInfo/getResidentPage 查询用户/居民档案列表。
+
+        用户档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuResidentPageResponse
+            用户/居民档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(RESIDENT_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        resident_resp = ShanshuResidentPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return resident_resp
+
+    async def async_query_car_manage_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuCarManagePageResponse:
+        """调用 /api/space/carManage/pageCarManage 查询车辆档案列表。
+
+        车辆管理 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuCarManagePageResponse
+            车辆档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(CAR_MANAGE_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        car_manage_resp = ShanshuCarManagePageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return car_manage_resp
+
+    async def async_query_parking_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuParkingPageResponse:
+        """调用 /api/space/parking/parkingPage 查询车位档案列表。
+
+        车位档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuParkingPageResponse
+            车位档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(PARKING_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        parking_resp = ShanshuParkingPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return parking_resp
+
+    async def async_query_work_order_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuWorkOrderPageResponse:
+        """调用 /api/woreport/task/query/page 查询工单列表。
+
+        工单管理 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuWorkOrderPageResponse
+            工单分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(WORK_ORDER_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        work_order_resp = ShanshuWorkOrderPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return work_order_resp
+
+    async def async_query_mall_order_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuMallOrderPageResponse:
+        """调用 /api/retailmall/order/pageFront 查询园区商城订单列表。
+
+        商城订单 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuMallOrderPageResponse
+            商城订单分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(MALL_ORDER_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        mall_order_resp = ShanshuMallOrderPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return mall_order_resp
+
+    async def async_query_service_order_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuServiceOrderPageResponse:
+        """调用 /api/houseserve/order/pageFront 查询服务订单列表。
+
+        服务订单 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuServiceOrderPageResponse
+            服务订单分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(SERVICE_ORDER_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        service_order_resp = ShanshuServiceOrderPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return service_order_resp
+
+    async def async_query_approval_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuApprovalPageResponse:
+        """调用 /api/bpm/process/approval 查询审批数据列表。
+
+        审批管理 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuApprovalPageResponse
+            审批数据分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(APPROVAL_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        approval_resp = ShanshuApprovalPageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return approval_resp
+
+    async def async_query_approval_detail(
+        self,
+        *,
+        instance_id: str,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuApprovalDetailRecord:
+        """调用 /api/bpm/process/progress/{instance_id}/node_433279443693 查询审批详情。
+
+        这是一个 GET 请求接口，实例 ID 通过 URL 路径传递，节点 ID 固定为 ``node_433279443693``。
+
+        参数
+        ----------
+        instance_id : str
+            流程实例 ID (procInstId)。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuApprovalDetailRecord
+            审批详情响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 GET。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        url = APPROVAL_DETAIL_PATH.format(instance_id=instance_id)
+
+        resp = await self._client.get(url, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        approval_detail = ShanshuApprovalDetailRecord.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return approval_detail
+
+    async def async_query_owner_detail(
+        self,
+        *,
+        user_id: str,
+        community_id: str,
+        space_id: str,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuOwnerDetailRecord:
+        """调用 /api/space/archive/archive/detailSensitive 查询业主详情。
+
+        这是一个 GET 请求接口，参数通过 URL 查询字符串传递。
+
+        参数
+        ----------
+        user_id : str
+            用户 ID。
+        community_id : str
+            小区/社区 ID。
+        space_id : str
+            空间 ID（房产/车位等空间 ID）。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuOwnerDetailRecord
+            业主详情响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 GET。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        params: dict[str, str] = {
+            "userId": user_id,
+            "communityId": community_id,
+            "spaceId": space_id,
+        }
+
+        resp = await self._client.get(OWNER_DETAIL_PATH, params=params, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        owner_detail = ShanshuOwnerDetailRecord.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return owner_detail
+
+    async def async_query_archive_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuArchivePageResponse:
+        """调用 /api/space/archive/examine/page 查询业主档案列表。
+
+        业主档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuArchivePageResponse
+            业主档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(ARCHIVE_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        archive_resp = ShanshuArchivePageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return archive_resp
+
+    async def async_query_yard_archive_with_paginator(
+        self,
+        *,
+        params: ShanshuPageQueryParams | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> ShanshuYardArchivePageResponse:
+        """调用 /api/space/space/yardArchivePage 查询车场档案列表。
+
+        基础档案 -> 车场档案 列表和查询接口。
+
+        参数
+        ----------
+        params : ShanshuPageQueryParams, optional
+            分页查询参数，包含 conditions、count、last、order_by、page_num、page_size。
+        extra_headers : dict, optional
+            额外请求头，会合并到默认头中。
+
+        返回
+        -------
+        ShanshuYardArchivePageResponse
+            车场档案分页响应（使用 ``models`` 中的 pydantic 模型处理）。
+            返回体使用 ``models`` 中的 pydantic 模型解析，是否成功可通过 ``ok`` 属性判断。
+
+        规则
+        -----
+        - 请求头固定携带 ``client=co-pc`` 和缓存的 ``authorization`` token。
+        - 请求方法为 POST，提交参数为 JSON。
+        - 返回体不含 ``code`` 字段即视为成功。
+        """
+        token = self.token
+        headers: dict[str, str] = {"client": "co-pc"}
+        if token:
+            headers["authorization"] = token
+        if extra_headers:
+            headers.update(extra_headers)
+
+        page_params = params or ShanshuPageQueryParams()
+        payload: dict[str, Any] = {
+            "count": page_params.count,
+            "last": page_params.last,
+            "orderBy": page_params.order_by if page_params.order_by is not None else [],
+            "pageNum": page_params.page_num,
+            "pageSize": page_params.page_size,
+        }
+        if page_params.conditions is not None:
+            payload["conditions"] = page_params.conditions
+
+        resp = await self._client.post(YARD_ARCHIVE_PAGE_PATH, json=payload, headers=headers)
+
+        # 使用 models 中的 pydantic 模型解析返回体
+        try:
+            body = resp.json()
+        except Exception:
+            body = None
+
+        yard_archive_resp = ShanshuYardArchivePageResponse.model_validate(body)
+
+        # 同时校验 HTTP 状态码
+        resp.raise_for_status()
+
+        return yard_archive_resp
+
+    async def async_close(self) -> None:
+        """关闭底层 httpx.AsyncClient 客户端。"""
+        await self._client.aclose()
+
+    async def async_aenter__(self) -> "AsyncShanshuClient":
+        return self
+
+    async def async_aexit__(self, *args: Any) -> None:
+        await self.async_close()
+
+
+__all__ = [
+    "ShanshuClient",
+    "ShanshuClientConfig",
+    "ShanshuLoginError",
+    "DEFAULT_BASE_URL",
+    "COMMUNITY_FRONT_PAGE_PATH",
+    "AsyncShanshuClient",
+    "AsyncShanshuClientConfig",
+]