diff --git a/common/api.js b/common/api.js
index 990695f..692999f 100644
--- a/common/api.js
+++ b/common/api.js
@@ -32,8 +32,17 @@ function httpRequest(url, params) {
       success: (res) => {
         const code = res.statusCode
         if (code === 200 || code === 201 || code === 204) {
+          // 业务级错误：HTTP 200 但 fail:true
+          if (res.data && res.data.fail === true) {
+            const bizMsg = res.data.msg || '操作失败'
+            if (!silent) {
+              uni.showToast({ title: bizMsg, icon: 'none', duration: 2500 })
+            }
+            reject({ msg: bizMsg, code })
+            return
+          }
           resolve(res.data)
-        } else if (code === 401 || code === 418) {
+        } else if (code === 401 ) {
           // token/refresh_token 过期或无效，清除登录态
           uni.removeStorageSync('auth_token')
           uni.removeStorageSync('refresh_token')
@@ -76,8 +85,8 @@ function uploadRequest(url, params) {
 
     uni.uploadFile({
       url: url,
-      filePath: params.data.fileName || params.data.filePath,
-      name: params.data.name || 'file',
+      filePath: params.data.image || params.data.fileName || params.data.filePath,
+      name: params.data.name || 'image',
       header: headers,
       formData: params.data.formData || {},
       success: (uploadRes) => {
@@ -156,137 +165,146 @@ export async function refreshAuthToken() {
 }
 
 // ==========================================
-// 酒友圈 API（当前返回 Mock 数据，后端就绪后切换为 SDK 调用）
+// 酒友圈 API（基于 HaveADrink SDK 真实接口）
 // ==========================================
-import { MOCK_FEEDS, MOCK_COMMENTS, MOCK_FRIENDS, MOCK_FRIEND_REQUESTS, MOCK_EVENTS, MOCK_CONVERSATIONS, MOCK_MESSAGES } from './mock-data'
 
-/** 模拟网络延迟 */
-function mockDelay(data, ms = 300) {
-  return new Promise(resolve => setTimeout(() => resolve({ data }), ms))
-}
-
-/** 获取动态信息流 */
-export function GetCircleFeeds({ page = 1, pageSize = 10 } = {}) {
-  // TODO: 后端就绪后替换为 client.GetCircleFeeds(...)
-  const start = (page - 1) * pageSize
-  const list = MOCK_FEEDS.slice(start, start + pageSize)
-  return mockDelay({ list, total: MOCK_FEEDS.length, hasMore: start + pageSize < MOCK_FEEDS.length })
+/** 获取动态信息流（游标分页） */
+export async function GetCircleFeeds({ lastId = 0, pageSize = 10 } = {}) {
+  const res = await client.GetFeeds({ lastId, pageSize })
+  return { data: res }
 }
 
 /** 点赞动态 */
-export function LikeFeed({ feedId }) {
-  return mockDelay({ success: true })
+export async function LikeFeed({ feedId }) {
+  const res = await client.LikeFeed({ id: feedId })
+  return { data: res }
 }
 
 /** 取消点赞 */
-export function UnlikeFeed({ feedId }) {
-  return mockDelay({ success: true })
+export async function UnlikeFeed({ feedId }) {
+  const res = await client.UnlikeFeed({ id: feedId })
+  return { data: res }
 }
 
 /** 获取动态评论 */
-export function GetFeedComments({ feedId }) {
-  const list = MOCK_COMMENTS[feedId] || []
-  return mockDelay({ list })
+export async function GetFeedComments({ feedId }) {
+  const res = await client.GetFeedComments({ id: feedId })
+  return { data: res }
 }
 
 /** 发表评论 */
-export function AddComment({ feedId, content }) {
-  return mockDelay({ success: true, comment: { id: 'c_' + Date.now(), content, time: '刚刚' } })
+export async function AddComment({ feedId, content }) {
+  const res = await client.AddComment({ id: feedId, content })
+  return { data: res }
 }
 
 /** 发布动态 */
-export function PublishFeed({ text, images, recordId, visibility }) {
-  return mockDelay({ success: true, feedId: 'feed_' + Date.now() })
+export async function PublishFeed({ text, images, recordId, visibility }) {
+  const res = await client.PublishFeed({ text, images, recordId, visibility })
+  return { data: res }
 }
 
 /** 获取酒友列表 */
-export function GetFriends({ keyword = '' } = {}) {
-  const list = keyword
-    ? MOCK_FRIENDS.filter(f => f.nickname.includes(keyword))
-    : MOCK_FRIENDS
-  return mockDelay({ list })
+export async function GetFriends({ keyword = '' } = {}) {
+  const res = await client.GetFriends({ keyword })
+  return { data: res }
 }
 
 /** 获取好友请求 */
-export function GetFriendRequests() {
-  return mockDelay({ list: MOCK_FRIEND_REQUESTS })
+export async function GetFriendRequests() {
+  const res = await client.GetFriendRequests({})
+  return { data: res }
 }
 
 /** 发送好友请求 */
-export function SendFriendRequest({ userId }) {
-  return mockDelay({ success: true })
+export async function SendFriendRequest({ userId, message = '' }) {
+  const res = await client.SendFriendRequest({ userId, message })
+  return { data: res }
 }
 
 /** 接受好友请求 */
-export function AcceptFriendRequest({ requestId }) {
-  return mockDelay({ success: true })
+export async function AcceptFriendRequest({ requestId }) {
+  const res = await client.AcceptFriendRequest({ id: requestId })
+  return { data: res }
 }
 
 /** 删除酒友 */
-export function RemoveFriend({ userId }) {
-  return mockDelay({ success: true })
+export async function RemoveFriend({ userId }) {
+  const res = await client.RemoveFriend({ userId })
+  return { data: res }
 }
 
 /** 获取酒局列表 */
-export function GetEvents({ status = '' } = {}) {
-  const list = status ? MOCK_EVENTS.filter(e => e.status === status) : MOCK_EVENTS
-  return mockDelay({ list })
+export async function GetEvents({ status = '' } = {}) {
+  const res = await client.GetEvents({ status })
+  return { data: res }
 }
 
 /** 获取酒局详情 */
-export function GetEventDetail({ eventId }) {
-  const evt = MOCK_EVENTS.find(e => e.id === eventId) || MOCK_EVENTS[0]
-  return mockDelay(evt)
+export async function GetEventDetail({ eventId }) {
+  const res = await client.GetEventDetail({ id: eventId })
+  return { data: res }
 }
 
 /** 发起酒局 */
-export function CreateEvent({ title, time, location, maxPeople, note }) {
-  return mockDelay({ success: true, eventId: 'evt_' + Date.now() })
+export async function CreateEvent({ title, time, location, maxPeople, note, latitude, longitude }) {
+  const geo = (latitude != null && longitude != null) ? { latitude, longitude } : undefined
+  const res = await client.CreateEvent({ title, time, location, maxPeople, geo, note })
+  return { data: res }
 }
 
 /** 报名酒局 */
-export function JoinEvent({ eventId }) {
-  return mockDelay({ success: true })
+export async function JoinEvent({ eventId }) {
+  const res = await client.JoinEvent({ id: eventId })
+  return { data: res }
 }
 
 /** 取消报名 */
-export function QuitEvent({ eventId }) {
-  return mockDelay({ success: true })
+export async function QuitEvent({ eventId }) {
+  const res = await client.QuitEvent({ id: eventId })
+  return { data: res }
 }
 
 /** 酒局签到 */
-export function CheckInEvent({ eventId }) {
-  return mockDelay({ success: true })
+export async function CheckInEvent({ eventId }) {
+  const res = await client.CheckInEvent({ id: eventId })
+  return { data: res }
 }
 
 // ==========================================
-// 私信 API（当前返回 Mock 数据，后端就绪后切换为 SDK 调用）
+// 私信 API（基于 HaveADrink SDK 真实接口）
 // ==========================================
 
 /** 获取会话列表 */
-export function GetConversations() {
-  // TODO: 后端就绪后替换为 client.GetConversations(...)
-  return mockDelay({ list: MOCK_CONVERSATIONS })
+export async function GetConversations() {
+  const res = await client.GetConversations({})
+  return { data: res }
 }
 
-/** 获取历史消息 */
-export function GetMessages({ conversationId, page = 1, pageSize = 20 } = {}) {
-  // TODO: 后端就绪后替换为 client.GetMessages(...)
-  const all = MOCK_MESSAGES[conversationId] || []
-  const start = (page - 1) * pageSize
-  const list = all.slice(start, start + pageSize)
-  return mockDelay({ list, hasMore: start + pageSize < all.length })
+/** 获取历史消息（游标分页） */
+export async function GetMessages({ conversationId, lastID = 0, pageSize = 20 } = {}) {
+  const res = await client.GetMessages({ conversationId, lastID, pageSize })
+  return { data: res }
 }
 
 /** 标记会话已读 */
-export function MarkRead({ conversationId }) {
-  // TODO: 后端就绪后替换为 client.MarkRead(...)
-  return mockDelay({ success: true })
+export async function MarkRead({ conversationId }) {
+  const res = await client.MarkRead({ id: conversationId })
+  return { data: res }
 }
 
 /** 获取未读消息总数 */
-export function GetUnreadCount() {
-  // TODO: 后端就绪后替换为 client.GetUnreadCount(...)
-  const total = MOCK_CONVERSATIONS.reduce((sum, c) => sum + c.unread, 0)
-  return mockDelay({ total })
+export async function GetUnreadCount() {
+  const res = await client.GetUnreadCount({})
+  return { data: res }
+}
+
+// ==========================================
+// 文件上传 API
+// ==========================================
+
+/** 上传图片（返回 url） */
+export async function UploadImage({ filePath }) {
+  const res = await client.UploadImage({ image: filePath })
+  return { data: res }
 }
diff --git a/common/websocket.js b/common/websocket.js
index ec73149..bd936e8 100644
--- a/common/websocket.js
+++ b/common/websocket.js
@@ -1,9 +1,29 @@
 /* 碰盏日记 - WebSocket 管理器
  * 单例模式，负责私信实时通信
+ * 协议格式与 HaveADrink SDK ChatWebSocket 一致：{ mesgType, data }
  * 支持心跳、自动重连、消息队列
  */
 
-const WS_HOST = 'wss://dev.wash-painting.cn/ws'
+const WS_HOST = 'wss://dev.wash-painting.cn/api/have_a_drink/v1/chat/chat'
+
+// 客户端消息类型（与 SDK ClientMesgType 枚举值一致）
+const ClientMesgType = {
+  Chat: 'chat',
+  Typing: 'typing',
+  Read: 'read',
+  Ping: 'ping'
+}
+
+// 服务端消息类型（与 SDK ServerMesgType 枚举值一致）
+const ServerMesgType = {
+  Chat: 'chat',
+  Typing: 'typing',
+  Read: 'read',
+  Ack: 'ack',
+  Pong: 'pong',
+  Connected: 'connected',
+  Kicked: 'kicked'
+}
 
 class WebSocketManager {
   constructor() {
@@ -21,6 +41,7 @@ class WebSocketManager {
     this.heartbeatWait = 60000       // 60s 无 pong 则重连
     this.manualClose = false
     this.token = ''
+    this.userId = ''          // 连接成功后服务端返回的用户ID
   }
 
   /**
@@ -37,11 +58,14 @@ class WebSocketManager {
     this.manualClose = false
     this.isConnecting = true
 
-    const url = `${WS_HOST}?token=${this.token}`
-    console.log('[WS] 正在连接...', url)
+    const url = WS_HOST
+    console.log('[WS] 正在连接...')
 
     this.socketTask = uni.connectSocket({
       url,
+      header: {
+        'Authorization': `Bearer ${this.token}`
+      },
       complete: () => {}
     })
 
@@ -95,17 +119,17 @@ class WebSocketManager {
   }
 
   /**
-   * 发送消息
-   * @param {string} type - 消息类型: chat | typing | read | ping
+   * 发送消息（与 SDK writeClient* 方法格式一致）
+   * @param {string} mesgType - 消息类型: chat | typing | read | ping
    * @param {object} data - 消息数据
    */
-  send(type, data = {}) {
-    const payload = JSON.stringify({ type, data, ts: Date.now() })
+  send(mesgType, data = {}) {
+    const payload = JSON.stringify({ mesgType, data })
     if (this.isConnected && this.socketTask) {
       this.socketTask.send({ data: payload })
     } else {
-      // 断线暂存队列
-      if (type !== 'ping') {
+      // 断线暂存队列（ping 不暂存）
+      if (mesgType !== ClientMesgType.Ping) {
         this.messageQueue.push(payload)
       }
       // 尝试重连
@@ -117,7 +141,7 @@ class WebSocketManager {
 
   /**
    * 订阅事件
-   * @param {string} event - message | typing | read | ack | connect | disconnect
+   * @param {string} event - message | typing | read | ack | connected | kicked | connect | disconnect
    * @param {function} callback
    */
   on(event, callback) {
@@ -143,27 +167,38 @@ class WebSocketManager {
 
   // ========== 内部方法 ==========
 
-  /** 处理收到的消息 */
+  /** 处理收到的消息（SDK ServerMesgType 协议） */
   _handleMessage(msg) {
-    const { type, data } = msg
-    switch (type) {
-      case 'pong':
-        this._onPong()
-        break
-      case 'chat':
+    const { mesgType, data } = msg
+    switch (mesgType) {
+      case ServerMesgType.Chat:
         this._emit('message', data)
         break
-      case 'typing':
+      case ServerMesgType.Typing:
         this._emit('typing', data)
         break
-      case 'read':
+      case ServerMesgType.Read:
         this._emit('read', data)
         break
-      case 'ack':
+      case ServerMesgType.Ack:
         this._emit('ack', data)
         break
+      case ServerMesgType.Pong:
+        this._onPong()
+        break
+      case ServerMesgType.Connected:
+        // 服务端验证 token 成功后推送，携带 userId
+        this.userId = data && data.userId ? data.userId : ''
+        console.log('[WS] 服务端确认连接, userId:', this.userId)
+        this._emit('connected', data)
+        break
+      case ServerMesgType.Kicked:
+        console.warn('[WS] 被踢下线')
+        this._emit('kicked', data)
+        this.disconnect()
+        break
       default:
-        console.log('[WS] 未知消息类型', type)
+        console.log('[WS] 未知消息类型', mesgType)
     }
   }
 
@@ -181,7 +216,7 @@ class WebSocketManager {
   _startHeartbeat() {
     this._stopHeartbeat()
     this.heartbeatTimer = setInterval(() => {
-      this.send('ping')
+      this.send(ClientMesgType.Ping, {})
       // 设置超时检测
       this.heartbeatTimeout = setTimeout(() => {
         console.warn('[WS] 心跳超时，触发重连')
diff --git a/components/EventCard.vue b/components/EventCard.vue
index 5a63155..093353e 100644
--- a/components/EventCard.vue
+++ b/components/EventCard.vue
@@ -49,8 +49,9 @@ export default {
   emits: ['item-click'],
   computed: {
     statusLabel() {
-      const map = { open: '报名中', ongoing: '进行中', ended: '已结束' }
-      return map[this.event.status] || '报名中'
+      const val = String(this.event.status).toLowerCase()
+      const map = { open: '报名中', upcoming: '待开始', ongoing: '进行中', ended: '已结束' }
+      return map[val] || '报名中'
     }
   }
 }
@@ -80,6 +81,9 @@ export default {
   &.status-open {
     background: rgba(94,198,160,0.12);
   }
+  &.status-upcoming {
+    background: rgba(139,133,184,0.12);
+  }
   &.status-ongoing {
     background: rgba(232,168,56,0.12);
   }
@@ -93,6 +97,7 @@ export default {
   font-weight: $fw-medium;
 
   .status-open & { color: $mint; }
+  .status-upcoming & { color: $lavender; }
   .status-ongoing & { color: $amber; }
   .status-ended & { color: $text-tertiary; }
 }
diff --git a/components/FeedCard.vue b/components/FeedCard.vue
index 833e148..ef3e87b 100644
--- a/components/FeedCard.vue
+++ b/components/FeedCard.vue
@@ -73,8 +73,15 @@ export default {
     getCatIcon,
     isIconPath,
     feelingLabel(f) {
-      const map = { sober: '😌 清醒', buzzed: '😊 微醺', tipsy: '😄 小醉', drunk: '🥴 喝多了' }
-      return map[f] || '🍻 喝了点'
+      const val = String(f).toLowerCase()
+      const map = {
+        tipsy: '😌 微醺',
+        buzzed: '😊 到位',
+        drunk: '🥴 醉了',
+        blackout: '😵 断片',
+        sober: '😌 清醒'
+      }
+      return map[val] || '🍻 喝了点'
     }
   }
 }
diff --git a/manifest.json b/manifest.json
index 34a3d2d..581b39e 100644
--- a/manifest.json
+++ b/manifest.json
@@ -46,6 +46,7 @@
                 "desc" : "用于选择酒局地点和导航"
             }
         },
+        "requiredPrivateInfos" : ["chooseLocation", "getLocation"],
         "optimization" : {
             "subPackages" : true
         }
diff --git a/node_modules/.package-lock.json b/node_modules/.package-lock.json
index f930d21..1c06d3e 100644
--- a/node_modules/.package-lock.json
+++ b/node_modules/.package-lock.json
@@ -4,9 +4,9 @@
   "requires": true,
   "packages": {
     "node_modules/HaveADrink": {
-      "version": "1.0.4",
-      "resolved": "https://npm.wash-painting.cn/HaveADrink/-/HaveADrink-1.0.4.tgz",
-      "integrity": "sha512-kSSpTZrQGjRueftSAopurZcwXGMS3oKQ0mvP3/sePJh7odO5ev9FT31isXX0LLmL1HojzB4nrIeDb/PTdGhYuA==",
+      "version": "1.0.8",
+      "resolved": "https://npm.wash-painting.cn/HaveADrink/-/HaveADrink-1.0.8.tgz",
+      "integrity": "sha512-YOaqEZg+T1MKz1OtRJc09niyxEwm+52g91Yj0L2aGEy6bK6pTLJYlmREdneIStiniUGHVjL2/U5Qk57lTBAuFw==",
       "license": "ISC"
     }
   }
diff --git a/node_modules/HaveADrink/README.md b/node_modules/HaveADrink/README.md
index d0744e1..fbd048a 100644
--- a/node_modules/HaveADrink/README.md
+++ b/node_modules/HaveADrink/README.md
@@ -14,7 +14,7 @@
  * 6. 社交模块 - 朋友圈动态、点赞
  
 
-**版本:** v1.0.4
+**版本:** v1.0.8
 
 ## 安装
 
@@ -350,58 +350,6 @@ const req = new GetFeedReq()
 client.GetFeed(req).then(...).catch(...)
 ```
 
-###  点赞
-
-
-
-<font color="green">POST</font> `/api/have_a_drink/v1/communication/records/like`
-
-#### 请求参数
-|名称|类型|校验规则|说明|
-|:-|:-|:-|:-|
-|id|`string\|number`|required| 记录ID|
-
-
-
-
-#### 返回值
-|名称|类型|说明|
-|:-|:-:|:-|
-
-
-
-
-```javascript
-const req = new LikeRecordReq()
-client.LikeRecord(req).then(...).catch(...)
-```
-
-###  取消点赞
-
-
-
-<font color="green">POST</font> `/api/have_a_drink/v1/communication/records/unlike`
-
-#### 请求参数
-|名称|类型|校验规则|说明|
-|:-|:-|:-|:-|
-|id|`string\|number`|required| 记录ID|
-
-
-
-
-#### 返回值
-|名称|类型|说明|
-|:-|:-:|:-|
-
-
-
-
-```javascript
-const req = new LikeRecordReq()
-client.UnlikeRecord(req).then(...).catch(...)
-```
-
 ###  上传照片
 
 
@@ -479,7 +427,7 @@ client.UploadPhotos(req).then(...).catch(...)
 **DrinkItem**
 |名称|类型|校验规则|说明|
 |:-|:-|:-|:-|
-|category|`Category`|required| 酒类分类ID|
+|category|`Category`|| 酒类分类ID|
 |brand|`string`|required| 品牌名称|
 |product|`string`|| 产品名|
 |amount|`number`|required,gt=0| 饮用量数值|
@@ -532,7 +480,7 @@ client.UploadPhotos(req).then(...).catch(...)
 **FoodInfo**
 |名称|类型|校验规则|说明|
 |:-|:-|:-|:-|
-|category|`FoodCategory`|required| 配餐分类ID|
+|category|`FoodCategory`|| 配餐分类ID|
 |name|`string`|| 具体菜名|
 
 
@@ -1193,3 +1141,809 @@ client.UpdatePreferences(req).then(...).catch(...)
 const req = new UploadImageReq()
 client.UploadImage(req).then(...).catch(...)
 ```
+
+###  动态信息流
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/moments/feeds`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|lastId|`string\|number`|| 最后一条动态ID，用于分页|
+|pageSize|`number`|| 每页数量|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|list|`Array<Feed>`| 动态列表<br>|
+|hasMore|`boolean`| 是否还有更多动态<br>|
+
+
+
+**Feed**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 动态ID|
+|userId|`string\|number`| 用户ID|
+|nickname|`string`| 昵称|
+|avatar|`string`| 头像|
+|time|`string`| 发布时间|
+|text|`string`| 动态文本|
+|drinks|`Array<DrinkTag>`| 酒水标签|
+|feeling|`Feeling`| 自我感觉|
+|images|`Array<string>`| 图片列表|
+|likes|`number`| 点赞数|
+|liked|`boolean`| 是否点赞|
+|comments|`number`| 评论数|
+
+
+**DrinkTag**
+|名称|类型|说明|
+|:-|:-|:-|
+|category|`Category`| 酒类分类|
+|name|`string`| 酒类名称|
+|amount|`number`| 酒类数量|
+
+
+**Feeling**
+|名称|值|类型|说明|
+|:-|:-:|:-|:-|
+|Tipsy|"tipsy"|`Feeling`|微醺|
+|Buzzed|"buzzed"|`Feeling`|到位|
+|Drunk|"drunk"|`Feeling`|醉了|
+|Blackout|"blackout"|`Feeling`|断片|
+
+
+
+```javascript
+const req = new GetFeedsReq()
+client.GetFeeds(req).then(...).catch(...)
+```
+
+###  发布动态
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/moments/feeds`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|text|`string`|| 动态文本|
+|images|`Array<string>`|| 图片列表|
+|recordId|`string\|number`|| 关联的记录ID|
+|visibility|`Visibility`|公开: Visibility.Public = "public"<br>仅好友: Visibility.Friends = "friends"<br>仅自己: Visibility.Private = "private"| 可见性|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|success|`boolean`| 是否成功<br>|
+|feedId|`string\|number`| 动态ID<br>|
+
+
+
+
+```javascript
+const req = new PublishFeedReq()
+client.PublishFeed(req).then(...).catch(...)
+```
+
+###  点赞
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/moments/feeds/like`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 动态ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|ok|`boolean`| 是否成功<br>|
+
+
+
+
+```javascript
+const req = new LikeFeedReq()
+client.LikeFeed(req).then(...).catch(...)
+```
+
+###  取消点赞
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/moments/feeds/unlike`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 动态ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|ok|`boolean`| 是否成功<br>|
+
+
+
+
+```javascript
+const req = new UnlikeFeedReq()
+client.UnlikeFeed(req).then(...).catch(...)
+```
+
+###  获取评论
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/moments/feeds/comments`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 动态ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|list|`Array<Comment>`| 评论列表<br>|
+
+
+
+**Comment**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 评论ID|
+|userId|`string\|number`| 用户ID|
+|nickname|`string`| 昵称|
+|avatar|`string`| 头像|
+|content|`string`| 评论内容|
+|time|`string`| 评论时间|
+
+
+
+```javascript
+const req = new GetFeedCommentsReq()
+client.GetFeedComments(req).then(...).catch(...)
+```
+
+###  发表评论
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/moments/feeds/comments`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 动态ID|
+|content|`string`|| 评论内容|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|id|`string\|number`| 评论ID<br>|
+|userId|`string\|number`| 用户ID<br>|
+|nickname|`string`| 昵称<br>|
+|avatar|`string`| 头像<br>|
+|content|`string`| 评论内容<br>|
+|time|`string`| 评论时间<br>|
+
+
+
+
+```javascript
+const req = new AddCommentFullReq()
+client.AddComment(req).then(...).catch(...)
+```
+
+###  酒友管理
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/friends/friends`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|keyword|`string`|| 搜索关键词|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|list|`Array<Friend>`| 分页数据<br>|
+
+
+
+**Friend**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 酒友ID|
+|nickname|`string`| 昵称|
+|avatar|`string`| 头像|
+|lastDrink|`string\|number`| 最近一次喝的酒|
+|lastDrinkTime|`string`| 最近一次喝的酒时间|
+|online|`boolean`| 是否在线|
+
+
+
+```javascript
+const req = new GetFriendsReq()
+client.GetFriends(req).then(...).catch(...)
+```
+
+###  好友请求管理
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/friends/friend-requests`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|list|`Array<FriendRequest>`| 分页数据<br>|
+
+
+
+**FriendRequest**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 好友请求ID|
+|userId|`string\|number`| 酒友ID|
+|nickname|`string`| 昵称|
+|avatar|`string`| 头像|
+|message|`string`| 消息|
+|time|`string`| 创建时间|
+
+
+
+```javascript
+const req = new GetFriendRequestsReq()
+client.GetFriendRequests(req).then(...).catch(...)
+```
+
+###  发送好友请求
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/friends/friend-requests`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|userId|`string\|number`|| 酒友ID|
+|message|`string`|| 消息|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+
+
+
+
+```javascript
+const req = new SendFriendRequestReq()
+client.SendFriendRequest(req).then(...).catch(...)
+```
+
+###  接受好友请求
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/friends/friend-requests/accept`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 好友请求ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+
+
+
+
+```javascript
+const req = new AcceptFriendRequestReq()
+client.AcceptFriendRequest(req).then(...).catch(...)
+```
+
+###  删除酒友
+
+
+
+<font color="green">DELETE</font> `/api/have_a_drink/v1/friends/friends`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|userId|`string\|number`|| 酒友ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+
+
+
+
+```javascript
+const req = new RemoveFriendReq()
+client.RemoveFriend(req).then(...).catch(...)
+```
+
+###  约酒活动
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/events/events`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|status|`EventStatus`|开放报名: EventStatus.Open = 1<br>待开始: EventStatus.Upcoming = 2<br>进行中: EventStatus.Ongoing = 3<br>已结束: EventStatus.Ended = 4| 状态筛选|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|list|`Array<Event>`| 分页数据<br>|
+
+
+
+**Event**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 酒局ID|
+|title|`string`| 酒局标题|
+|organizer|`User`| 酒局组织者|
+|time|`string`| 酒局时间|
+|location|`string`| 酒局地点|
+|maxPeople|`number`| 最大人数|
+|joined|`number`| 已报名人数|
+|participants|`Array<User>`| 已报名用户|
+|status|`EventStatus`| 酒局状态|
+|note|`string`| 酒局备注|
+|isJoined|`boolean`| 是否已报名|
+|isOrganizer|`boolean`| 是否为组织者|
+
+
+**User**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 用户ID|
+|nickname|`string`| 用户昵称|
+|avatar|`string`| 头像URL|
+|joinedAt|`string`| 加入时间|
+|preferences|`UserPreferences`| 用户偏好|
+
+
+**UserPreferences**
+|名称|类型|说明|
+|:-|:-|:-|
+|favoriteCategories|`Array<Category>`| 偏好酒类ID列表|
+|frequency|`Frequency`| 饮酒频率|
+
+
+**Frequency**
+|名称|值|类型|说明|
+|:-|:-:|:-|:-|
+|Rarely|"rarely"|`Frequency`|很少|
+|Sometimes|"sometimes"|`Frequency`|有时|
+|Often|"often"|`Frequency`|经常|
+
+
+**EventStatus**
+|名称|值|类型|说明|
+|:-|:-:|:-|:-|
+|Open|1|`EventStatus`|开放报名|
+|Upcoming|2|`EventStatus`|待开始|
+|Ongoing|3|`EventStatus`|进行中|
+|Ended|4|`EventStatus`|已结束|
+
+
+
+```javascript
+const req = new GetEventsReq()
+client.GetEvents(req).then(...).catch(...)
+```
+
+###  获取酒局详情
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/events/events/detail`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 酒局ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|id|`string\|number`| 酒局ID<br>|
+|title|`string`| 酒局标题<br>|
+|organizer|`User`| 酒局组织者<br>|
+|time|`string`| 酒局时间<br>|
+|location|`string`| 酒局地点<br>|
+|maxPeople|`number`| 最大人数<br>|
+|joined|`number`| 已报名人数<br>|
+|participants|`Array<User>`| 已报名用户<br>|
+|status|`EventStatus`| 酒局状态<br>开放报名: EventStatus.Open = 1<br>待开始: EventStatus.Upcoming = 2<br>进行中: EventStatus.Ongoing = 3<br>已结束: EventStatus.Ended = 4|
+|note|`string`| 酒局备注<br>|
+|isJoined|`boolean`| 是否已报名<br>|
+|isOrganizer|`boolean`| 是否为组织者<br>|
+
+
+
+**User**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 用户ID|
+|nickname|`string`| 用户昵称|
+|avatar|`string`| 头像URL|
+|joinedAt|`string`| 加入时间|
+|preferences|`UserPreferences`| 用户偏好|
+
+
+**UserPreferences**
+|名称|类型|说明|
+|:-|:-|:-|
+|favoriteCategories|`Array<Category>`| 偏好酒类ID列表|
+|frequency|`Frequency`| 饮酒频率|
+
+
+
+```javascript
+const req = new GetEventDetailReq()
+client.GetEventDetail(req).then(...).catch(...)
+```
+
+###  发起酒局
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/events/events`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|title|`string`|| 酒局标题|
+|time|`string`|| 酒局时间|
+|location|`string`|| 酒局地点|
+|maxPeople|`number`|| 最大人数|
+|geo|`GeoPoint`|| 坐标信息|
+|note|`string`|| 酒局备注|
+
+
+
+**GeoPoint**
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|latitude|`number`|| 纬度|
+|longitude|`number`|| 经度|
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|eventId|`string\|number`| 酒局ID<br>|
+
+
+
+
+```javascript
+const req = new CreateEventReq()
+client.CreateEvent(req).then(...).catch(...)
+```
+
+###  报名酒局
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/events/events/join`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 酒局ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|ok|`boolean`| 是否成功<br>|
+
+
+
+
+```javascript
+const req = new JoinEventReq()
+client.JoinEvent(req).then(...).catch(...)
+```
+
+###  取消报名酒局
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/events/events/quit`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 酒局ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|ok|`boolean`| 是否成功<br>|
+
+
+
+
+```javascript
+const req = new QuitEventReq()
+client.QuitEvent(req).then(...).catch(...)
+```
+
+###  签到酒局
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/events/events/checkin`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string\|number`|| 酒局ID|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|ok|`boolean`| 是否成功<br>|
+
+
+
+
+```javascript
+const req = new CheckInEventReq()
+client.CheckInEvent(req).then(...).catch(...)
+```
+
+###  获取会话列表
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/chat/conversations`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|list|`Array<Conversation>`| 会话列表<br>|
+
+
+
+**Conversation**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string`| 会话ID|
+|friendId|`string\|number`| 对方用户ID|
+|nickname|`string`| 对方昵称|
+|avatar|`string`| 对方头像URL（可为空）|
+|lastMessage|`string`| 最后一条消息摘要|
+|lastTime|`string`| 最后消息时间（ISO 8601）|
+|unread|`number`| 未读消息数|
+|online|`boolean`| 对方是否在线|
+
+
+
+```javascript
+const req = new GetConversationsReq()
+client.GetConversations(req).then(...).catch(...)
+```
+
+###  获取历史消息
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/chat/messages`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|conversationId|`string`|required| 会话ID|
+|lastID|`string\|number`|| 游标分页|
+|pageSize|`number`|gt=0,lte=100| 每页数量，默认20|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|list|`Array<Message>`| 消息列表<br>|
+|hasMore|`boolean`| 是否还有更多消息<br>|
+
+
+
+**Message**
+|名称|类型|说明|
+|:-|:-|:-|
+|id|`string\|number`| 消息ID|
+|conversationId|`string`| 会话ID|
+|senderId|`string\|number`| 发送者ID|
+|receiverId|`string\|number`| 接收者ID|
+|type|`MessageType`| 消息类型|
+|content|`string`| 消息内容|
+|timestamp|`number`| 发送时间（毫秒时间戳）|
+|status|`MessageStatus`| 消息状态|
+
+
+**MessageType**
+|名称|值|类型|说明|
+|:-|:-:|:-|:-|
+|Text|"text"|`MessageType`|文本消息|
+|Image|"image"|`MessageType`|图片消息|
+
+
+**MessageStatus**
+|名称|值|类型|说明|
+|:-|:-:|:-|:-|
+|Sending|"sending"|`MessageStatus`|发送中|
+|Sent|"sent"|`MessageStatus`|已发送|
+|Delivered|"delivered"|`MessageStatus`|已送达|
+|Read|"read"|`MessageStatus`|已读|
+
+
+
+```javascript
+const req = new GetMessagesReq()
+client.GetMessages(req).then(...).catch(...)
+```
+
+###  标记会话已读
+
+
+
+<font color="green">POST</font> `/api/have_a_drink/v1/chat/conversations/read`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|id|`string`|required| 会话ID（路径参数）|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|success|`boolean`| 是否成功<br>|
+
+
+
+
+```javascript
+const req = new MarkReadReq()
+client.MarkRead(req).then(...).catch(...)
+```
+
+###  获取未读消息总数
+
+
+
+<font color="green">GET</font> `/api/have_a_drink/v1/chat/unread-count`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|total|`number`| 未读总数<br>|
+
+
+
+
+```javascript
+const req = new GetUnreadCountReq()
+client.GetUnreadCount(req).then(...).catch(...)
+```
+
+###  注意：连接建立后，服务端会先验证 token，然后推送 connected 事件
+
+
+
+<font color="green">WS</font> `/api/have_a_drink/v1/chat/chat`
+
+#### 请求参数
+|名称|类型|校验规则|说明|
+|:-|:-|:-|:-|
+|mesgType|`ClientMesgType`|发送消息: ClientMesgType.Chat = "chat"<br>输入状态: ClientMesgType.Typing = "typing"<br>已读回执: ClientMesgType.Read = "read"<br>心跳: ClientMesgType.Ping = "ping"| 消息类型|
+|data|`ClientMessage`|| 消息数据|
+
+
+
+
+#### 返回值
+|名称|类型|说明|
+|:-|:-:|:-|
+|mesgType|`ServerMesgType`| 消息类型<br>推送新消息: ServerMesgType.Chat = "chat"<br>对方输入状态: ServerMesgType.Typing = "typing"<br>对方已读回执: ServerMesgType.Read = "read"<br>消息送达确认: ServerMesgType.Ack = "ack"<br>心跳响应: ServerMesgType.Pong = "pong"<br>连接成功: ServerMesgType.Connected = "connected"<br>被踢下线: ServerMesgType.Kicked = "kicked"|
+|data|`ServerMessage`| 消息数据<br>|
+
+
+
+
+```javascript
+const req = new ChatWebSocket()
+client.ChatWebSocket(req).then(...).catch(...)
+```
diff --git a/node_modules/HaveADrink/index.d.ts b/node_modules/HaveADrink/index.d.ts
index 9cd4cd6..32e119d 100644
--- a/node_modules/HaveADrink/index.d.ts
+++ b/node_modules/HaveADrink/index.d.ts
@@ -263,6 +263,135 @@ export declare class Frequency extends Enum {
     static getLabel(v: number|string): string;
 }
 
+/**
+ * 酒局状态
+ */
+export declare class EventStatus extends Enum {
+    /**
+     * 开放报名
+     */
+    static Open: EventStatus;
+    /**
+     * 待开始
+     */
+    static Upcoming: EventStatus;
+    /**
+     * 进行中
+     */
+    static Ongoing: EventStatus;
+    /**
+     * 已结束
+     */
+    static Ended: EventStatus;
+
+    static entries(): Array<option>;
+    static getLabel(v: number|string): string;
+}
+
+/**
+ * 消息类型（文本/图片）
+ */
+export declare class MessageType extends Enum {
+    /**
+     * 文本消息
+     */
+    static Text: MessageType;
+    /**
+     * 图片消息
+     */
+    static Image: MessageType;
+
+    static entries(): Array<option>;
+    static getLabel(v: number|string): string;
+}
+
+/**
+ * 消息状态（发送、送达、已读）
+ */
+export declare class MessageStatus extends Enum {
+    /**
+     * 发送中
+     */
+    static Sending: MessageStatus;
+    /**
+     * 已发送
+     */
+    static Sent: MessageStatus;
+    /**
+     * 已送达
+     */
+    static Delivered: MessageStatus;
+    /**
+     * 已读
+     */
+    static Read: MessageStatus;
+
+    static entries(): Array<option>;
+    static getLabel(v: number|string): string;
+}
+
+/**
+ * 客户端 WebSocket 消息类型
+ */
+export declare class ClientMesgType extends Enum {
+    /**
+     * 发送消息
+     */
+    static Chat: ClientMesgType;
+    /**
+     * 输入状态
+     */
+    static Typing: ClientMesgType;
+    /**
+     * 已读回执
+     */
+    static Read: ClientMesgType;
+    /**
+     * 心跳
+     */
+    static Ping: ClientMesgType;
+
+    static entries(): Array<option>;
+    static getLabel(v: number|string): string;
+}
+
+/**
+ * 服务端 WebSocket 消息类型
+ */
+export declare class ServerMesgType extends Enum {
+    /**
+     * 推送新消息
+     */
+    static Chat: ServerMesgType;
+    /**
+     * 对方输入状态
+     */
+    static Typing: ServerMesgType;
+    /**
+     * 对方已读回执
+     */
+    static Read: ServerMesgType;
+    /**
+     * 消息送达确认
+     */
+    static Ack: ServerMesgType;
+    /**
+     * 心跳响应
+     */
+    static Pong: ServerMesgType;
+    /**
+     * 连接成功
+     */
+    static Connected: ServerMesgType;
+    /**
+     * 被踢下线
+     */
+    static Kicked: ServerMesgType;
+
+    static entries(): Array<option>;
+    static getLabel(v: number|string): string;
+}
+
 
 /**
  * 手机号
@@ -372,6 +501,23 @@ export declare class Ok {
     static fromObject(o: Object): Ok;
 }
 
+/**
+ * 用于表示无数据
+ */
+export declare class None {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 None
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): None;
+}
+
 /**
  * 微信登录请求参数
  */
@@ -968,46 +1114,6 @@ export declare class FeedPageData {
     static fromObject(o: Object): FeedPageData;
 }
 
-/**
- * 点赞/取消点赞请求
- */
-export declare class LikeRecordReq {
-    [key: string]: any;
-    /**
-    * 记录ID
-    */
-    id: string|number;
-    
-    /**
-     * @param id string|number  记录ID
-     */
-    constructor(id: string|number,);
-    /**
-     * 从对象创建 LikeRecordReq
-     *
-     * @param o Object 
-     * - id: string|number, //  记录ID
-     */
-    static fromObject(o: Object): LikeRecordReq;
-}
-
-/**
- * 点赞/取消点赞响应
- */
-export declare class LikeRecordResp {
-    [key: string]: any;
-    
-    /**
-     */
-    constructor();
-    /**
-     * 从对象创建 LikeRecordResp
-     *
-     * @param o Object 
-     */
-    static fromObject(o: Object): LikeRecordResp;
-}
-
 /**
  * 上传照片请求
  */
@@ -2414,10 +2520,6 @@ export declare class UploadImageResp {
 export declare class ReferenceFileReq {
     [key: string]: any;
     /**
-    * 项目名称
-    */
-    project: string;
-    /**
     * 模块名称
     */
     module: string;
@@ -2431,17 +2533,15 @@ export declare class ReferenceFileReq {
     urls: Array<string>;
     
     /**
-     * @param project string  项目名称
      * @param module string  模块名称
      * @param data number  数据 id
      * @param urls Array<string>  文件 urls
      */
-    constructor(project: string,module: string,data: number,urls: Array<string>,);
+    constructor(module: string,data: number,urls: Array<string>,);
     /**
      * 从对象创建 ReferenceFileReq
      *
      * @param o Object 
-     * - project: string, //  项目名称
      * - module: string, //  模块名称
      * - data: number, //  数据 id
      * - urls: Array<string>, //  文件 urls
@@ -2582,7 +2682,1968 @@ export declare class DeleteDataResp {
     static fromObject(o: Object): DeleteDataResp;
 }
 
+/**
+ * 酒水标签
+ */
+export declare class DrinkTag {
+    [key: string]: any;
+    /**
+    * 酒类分类
+    */
+    category: Category;
+    /**
+    * 酒类名称
+    */
+    name: string;
+    /**
+    * 酒类数量
+    */
+    amount: number;
+    
+    /**
+     * @param category Category  酒类分类
+     * @param name string  酒类名称
+     * @param amount number  酒类数量
+     */
+    constructor(category: Category,name: string,amount: number,);
+    /**
+     * 从对象创建 DrinkTag
+     *
+     * @param o Object 
+     * - category: Category, //  酒类分类
+     * - name: string, //  酒类名称
+     * - amount: number, //  酒类数量
+     */
+    static fromObject(o: Object): DrinkTag;
+}
 
+/**
+ * 获取酒友圈动态请求
+ */
+export declare class GetFeedsReq {
+    [key: string]: any;
+    /**
+    * 最后一条动态ID，用于分页
+    */
+    lastId: string|number;
+    /**
+    * 每页数量
+    */
+    pageSize: number;
+    
+    /**
+     * @param lastId string|number  最后一条动态ID，用于分页
+     * @param pageSize number  每页数量
+     */
+    constructor(lastId: string|number,pageSize: number,);
+    /**
+     * 从对象创建 GetFeedsReq
+     *
+     * @param o Object 
+     * - lastId: string|number, //  最后一条动态ID，用于分页
+     * - pageSize: number, //  每页数量
+     */
+    static fromObject(o: Object): GetFeedsReq;
+}
+
+/**
+ * 动态信息
+ */
+export declare class Feed {
+    [key: string]: any;
+    /**
+    * 动态ID
+    */
+    id: string|number;
+    /**
+    * 用户ID
+    */
+    userId: string|number;
+    /**
+    * 昵称
+    */
+    nickname: string;
+    /**
+    * 头像
+    */
+    avatar: string;
+    /**
+    * 发布时间
+    */
+    time: string;
+    /**
+    * 动态文本
+    */
+    text: string;
+    /**
+    * 酒水标签
+    */
+    drinks: Array<DrinkTag>;
+    /**
+    * 自我感觉
+    */
+    feeling: Feeling;
+    /**
+    * 图片列表
+    */
+    images: Array<string>;
+    /**
+    * 点赞数
+    */
+    likes: number;
+    /**
+    * 是否点赞
+    */
+    liked: boolean;
+    /**
+    * 评论数
+    */
+    comments: number;
+    
+    /**
+     * @param id string|number  动态ID
+     * @param userId string|number  用户ID
+     * @param nickname string  昵称
+     * @param avatar string  头像
+     * @param time string  发布时间
+     * @param text string  动态文本
+     * @param drinks Array<DrinkTag>  酒水标签
+     * @param feeling Feeling  自我感觉
+     * @param images Array<string>  图片列表
+     * @param likes number  点赞数
+     * @param liked boolean  是否点赞
+     * @param comments number  评论数
+     */
+    constructor(id: string|number,userId: string|number,nickname: string,avatar: string,time: string,text: string,drinks: Array<DrinkTag>,feeling: Feeling,images: Array<string>,likes: number,liked: boolean,comments: number,);
+    /**
+     * 从对象创建 Feed
+     *
+     * @param o Object 
+     * - id: string|number, //  动态ID
+     * - userId: string|number, //  用户ID
+     * - nickname: string, //  昵称
+     * - avatar: string, //  头像
+     * - time: string, //  发布时间
+     * - text: string, //  动态文本
+     * - drinks: Array<DrinkTag>, //  酒水标签
+     * - feeling: Feeling, //  自我感觉
+     * - images: Array<string>, //  图片列表
+     * - likes: number, //  点赞数
+     * - liked: boolean, //  是否点赞
+     * - comments: number, //  评论数
+     */
+    static fromObject(o: Object): Feed;
+}
+
+/**
+ * 动态列表响应
+ */
+export declare class GetFeedsResp {
+    [key: string]: any;
+    /**
+    * 动态列表
+    */
+    list: Array<Feed>;
+    /**
+    * 是否还有更多动态
+    */
+    hasMore: boolean;
+    
+    /**
+     * @param list Array<Feed>  动态列表
+     * @param hasMore boolean  是否还有更多动态
+     */
+    constructor(list: Array<Feed>,hasMore: boolean,);
+    /**
+     * 从对象创建 GetFeedsResp
+     *
+     * @param o Object 
+     * - list: Array<Feed>, //  动态列表
+     * - hasMore: boolean, //  是否还有更多动态
+     */
+    static fromObject(o: Object): GetFeedsResp;
+}
+
+/**
+ * 发布动态请求
+ */
+export declare class PublishFeedReq {
+    [key: string]: any;
+    /**
+    * 动态文本
+    */
+    text: string;
+    /**
+    * 图片列表
+    */
+    images: Array<string>;
+    /**
+    * 关联的记录ID
+    */
+    recordId: string|number;
+    /**
+    * 可见性
+    */
+    visibility: Visibility;
+    
+    /**
+     * @param text string  动态文本
+     * @param images Array<string>  图片列表
+     * @param recordId string|number  关联的记录ID
+     * @param visibility Visibility  可见性
+     */
+    constructor(text: string,images: Array<string>,recordId: string|number,visibility: Visibility,);
+    /**
+     * 从对象创建 PublishFeedReq
+     *
+     * @param o Object 
+     * - text: string, //  动态文本
+     * - images: Array<string>, //  图片列表
+     * - recordId: string|number, //  关联的记录ID
+     * - visibility: Visibility, //  可见性
+     */
+    static fromObject(o: Object): PublishFeedReq;
+}
+
+/**
+ * 发布动态响应
+ */
+export declare class PublishFeedResp {
+    [key: string]: any;
+    /**
+    * 是否成功
+    */
+    success: boolean;
+    /**
+    * 动态ID
+    */
+    feedId: string|number;
+    
+    /**
+     * @param success boolean  是否成功
+     * @param feedId string|number  动态ID
+     */
+    constructor(success: boolean,feedId: string|number,);
+    /**
+     * 从对象创建 PublishFeedResp
+     *
+     * @param o Object 
+     * - success: boolean, //  是否成功
+     * - feedId: string|number, //  动态ID
+     */
+    static fromObject(o: Object): PublishFeedResp;
+}
+
+/**
+ * 点赞/取消点赞请求（路径参数）
+ */
+export declare class LikeFeedReq {
+    [key: string]: any;
+    /**
+    * 动态ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  动态ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 LikeFeedReq
+     *
+     * @param o Object 
+     * - id: string|number, //  动态ID
+     */
+    static fromObject(o: Object): LikeFeedReq;
+}
+
+/**
+ * 点赞响应
+ */
+export declare class LikeFeedResp {
+    [key: string]: any;
+    /**
+    * 是否成功
+    */
+    ok: boolean;
+    
+    /**
+     * @param ok boolean  是否成功
+     */
+    constructor(ok: boolean,);
+    /**
+     * 从对象创建 LikeFeedResp
+     *
+     * @param o Object 
+     * - ok: boolean, //  是否成功
+     */
+    static fromObject(o: Object): LikeFeedResp;
+}
+
+/**
+ * 
+ */
+export declare class UnlikeFeedReq {
+    [key: string]: any;
+    /**
+    * 动态ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  动态ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 UnlikeFeedReq
+     *
+     * @param o Object 
+     * - id: string|number, //  动态ID
+     */
+    static fromObject(o: Object): UnlikeFeedReq;
+}
+
+/**
+ * 取消点赞响应
+ */
+export declare class UnlikeFeedResp {
+    [key: string]: any;
+    /**
+    * 是否成功
+    */
+    ok: boolean;
+    
+    /**
+     * @param ok boolean  是否成功
+     */
+    constructor(ok: boolean,);
+    /**
+     * 从对象创建 UnlikeFeedResp
+     *
+     * @param o Object 
+     * - ok: boolean, //  是否成功
+     */
+    static fromObject(o: Object): UnlikeFeedResp;
+}
+
+/**
+ * 评论信息
+ */
+export declare class Comment {
+    [key: string]: any;
+    /**
+    * 评论ID
+    */
+    id: string|number;
+    /**
+    * 用户ID
+    */
+    userId: string|number;
+    /**
+    * 昵称
+    */
+    nickname: string;
+    /**
+    * 头像
+    */
+    avatar: string;
+    /**
+    * 评论内容
+    */
+    content: string;
+    /**
+    * 评论时间
+    */
+    time: string;
+    
+    /**
+     * @param id string|number  评论ID
+     * @param userId string|number  用户ID
+     * @param nickname string  昵称
+     * @param avatar string  头像
+     * @param content string  评论内容
+     * @param time string  评论时间
+     */
+    constructor(id: string|number,userId: string|number,nickname: string,avatar: string,content: string,time: string,);
+    /**
+     * 从对象创建 Comment
+     *
+     * @param o Object 
+     * - id: string|number, //  评论ID
+     * - userId: string|number, //  用户ID
+     * - nickname: string, //  昵称
+     * - avatar: string, //  头像
+     * - content: string, //  评论内容
+     * - time: string, //  评论时间
+     */
+    static fromObject(o: Object): Comment;
+}
+
+/**
+ * 评论列表响应
+ */
+export declare class CommentListData {
+    [key: string]: any;
+    /**
+    * 评论列表
+    */
+    list: Array<Comment>;
+    
+    /**
+     * @param list Array<Comment>  评论列表
+     */
+    constructor(list: Array<Comment>,);
+    /**
+     * 从对象创建 CommentListData
+     *
+     * @param o Object 
+     * - list: Array<Comment>, //  评论列表
+     */
+    static fromObject(o: Object): CommentListData;
+}
+
+/**
+ * 获取评论请求（路径参数）
+ */
+export declare class GetFeedCommentsReq {
+    [key: string]: any;
+    /**
+    * 动态ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  动态ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 GetFeedCommentsReq
+     *
+     * @param o Object 
+     * - id: string|number, //  动态ID
+     */
+    static fromObject(o: Object): GetFeedCommentsReq;
+}
+
+/**
+ * 发表评论请求（含路径参数）
+ */
+export declare class AddCommentFullReq {
+    [key: string]: any;
+    /**
+    * 动态ID
+    */
+    id: string|number;
+    /**
+    * 评论内容
+    */
+    content: string;
+    
+    /**
+     * @param id string|number  动态ID
+     * @param content string  评论内容
+     */
+    constructor(id: string|number,content: string,);
+    /**
+     * 从对象创建 AddCommentFullReq
+     *
+     * @param o Object 
+     * - id: string|number, //  动态ID
+     * - content: string, //  评论内容
+     */
+    static fromObject(o: Object): AddCommentFullReq;
+}
+
+/**
+ * 发表评论响应
+ */
+export declare class AddCommentResp {
+    [key: string]: any;
+    /**
+    * 评论ID
+    */
+    id: string|number;
+    /**
+    * 用户ID
+    */
+    userId: string|number;
+    /**
+    * 昵称
+    */
+    nickname: string;
+    /**
+    * 头像
+    */
+    avatar: string;
+    /**
+    * 评论内容
+    */
+    content: string;
+    /**
+    * 评论时间
+    */
+    time: string;
+    
+    /**
+     * @param id string|number  评论ID
+     * @param userId string|number  用户ID
+     * @param nickname string  昵称
+     * @param avatar string  头像
+     * @param content string  评论内容
+     * @param time string  评论时间
+     */
+    constructor(id: string|number,userId: string|number,nickname: string,avatar: string,content: string,time: string,);
+    /**
+     * 从对象创建 AddCommentResp
+     *
+     * @param o Object 
+     * - id: string|number, //  评论ID
+     * - userId: string|number, //  用户ID
+     * - nickname: string, //  昵称
+     * - avatar: string, //  头像
+     * - content: string, //  评论内容
+     * - time: string, //  评论时间
+     */
+    static fromObject(o: Object): AddCommentResp;
+}
+
+/**
+ * 酒友信息
+ */
+export declare class Friend {
+    [key: string]: any;
+    /**
+    * 酒友ID
+    */
+    id: string|number;
+    /**
+    * 昵称
+    */
+    nickname: string;
+    /**
+    * 头像
+    */
+    avatar: string;
+    /**
+    * 最近一次喝的酒
+    */
+    lastDrink: string|number;
+    /**
+    * 最近一次喝的酒时间
+    */
+    lastDrinkTime: string;
+    /**
+    * 是否在线
+    */
+    online: boolean;
+    
+    /**
+     * @param id string|number  酒友ID
+     * @param nickname string  昵称
+     * @param avatar string  头像
+     * @param lastDrink string|number  最近一次喝的酒
+     * @param lastDrinkTime string  最近一次喝的酒时间
+     * @param online boolean  是否在线
+     */
+    constructor(id: string|number,nickname: string,avatar: string,lastDrink: string|number,lastDrinkTime: string,online: boolean,);
+    /**
+     * 从对象创建 Friend
+     *
+     * @param o Object 
+     * - id: string|number, //  酒友ID
+     * - nickname: string, //  昵称
+     * - avatar: string, //  头像
+     * - lastDrink: string|number, //  最近一次喝的酒
+     * - lastDrinkTime: string, //  最近一次喝的酒时间
+     * - online: boolean, //  是否在线
+     */
+    static fromObject(o: Object): Friend;
+}
+
+/**
+ * 获取好友请求列表请求
+ */
+export declare class GetFriendRequestsReq {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 GetFriendRequestsReq
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): GetFriendRequestsReq;
+}
+
+/**
+ * 酒友列表响应
+ */
+export declare class GetFriendRequestsResp {
+    [key: string]: any;
+    /**
+    * 分页数据
+    */
+    list: Array<Friend>;
+    
+    /**
+     * @param list Array<Friend>  分页数据
+     */
+    constructor(list: Array<Friend>,);
+    /**
+     * 从对象创建 GetFriendRequestsResp
+     *
+     * @param o Object 
+     * - list: Array<Friend>, //  分页数据
+     */
+    static fromObject(o: Object): GetFriendRequestsResp;
+}
+
+/**
+ * 获取酒友列表请求
+ */
+export declare class GetFriendsReq {
+    [key: string]: any;
+    /**
+    * 搜索关键词
+    */
+    keyword: string;
+    
+    /**
+     * @param keyword string  搜索关键词
+     */
+    constructor(keyword: string,);
+    /**
+     * 从对象创建 GetFriendsReq
+     *
+     * @param o Object 
+     * - keyword: string, //  搜索关键词
+     */
+    static fromObject(o: Object): GetFriendsReq;
+}
+
+/**
+ * 好友请求信息
+ */
+export declare class FriendRequest {
+    [key: string]: any;
+    /**
+    * 好友请求ID
+    */
+    id: string|number;
+    /**
+    * 酒友ID
+    */
+    userId: string|number;
+    /**
+    * 昵称
+    */
+    nickname: string;
+    /**
+    * 头像
+    */
+    avatar: string;
+    /**
+    * 消息
+    */
+    message: string;
+    /**
+    * 创建时间
+    */
+    time: string;
+    
+    /**
+     * @param id string|number  好友请求ID
+     * @param userId string|number  酒友ID
+     * @param nickname string  昵称
+     * @param avatar string  头像
+     * @param message string  消息
+     * @param time string  创建时间
+     */
+    constructor(id: string|number,userId: string|number,nickname: string,avatar: string,message: string,time: string,);
+    /**
+     * 从对象创建 FriendRequest
+     *
+     * @param o Object 
+     * - id: string|number, //  好友请求ID
+     * - userId: string|number, //  酒友ID
+     * - nickname: string, //  昵称
+     * - avatar: string, //  头像
+     * - message: string, //  消息
+     * - time: string, //  创建时间
+     */
+    static fromObject(o: Object): FriendRequest;
+}
+
+/**
+ * 好友请求列表响应
+ */
+export declare class FriendRequestListData {
+    [key: string]: any;
+    /**
+    * 分页数据
+    */
+    list: Array<FriendRequest>;
+    
+    /**
+     * @param list Array<FriendRequest>  分页数据
+     */
+    constructor(list: Array<FriendRequest>,);
+    /**
+     * 从对象创建 FriendRequestListData
+     *
+     * @param o Object 
+     * - list: Array<FriendRequest>, //  分页数据
+     */
+    static fromObject(o: Object): FriendRequestListData;
+}
+
+/**
+ * 发送好友请求
+ */
+export declare class SendFriendRequestReq {
+    [key: string]: any;
+    /**
+    * 酒友ID
+    */
+    userId: string|number;
+    /**
+    * 消息
+    */
+    message: string;
+    
+    /**
+     * @param userId string|number  酒友ID
+     * @param message string  消息
+     */
+    constructor(userId: string|number,message: string,);
+    /**
+     * 从对象创建 SendFriendRequestReq
+     *
+     * @param o Object 
+     * - userId: string|number, //  酒友ID
+     * - message: string, //  消息
+     */
+    static fromObject(o: Object): SendFriendRequestReq;
+}
+
+/**
+ * 发送好友请求响应
+ */
+export declare class SendFriendRequestResp {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 SendFriendRequestResp
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): SendFriendRequestResp;
+}
+
+/**
+ * 接受好友请求（路径参数）
+ */
+export declare class AcceptFriendRequestReq {
+    [key: string]: any;
+    /**
+    * 好友请求ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  好友请求ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 AcceptFriendRequestReq
+     *
+     * @param o Object 
+     * - id: string|number, //  好友请求ID
+     */
+    static fromObject(o: Object): AcceptFriendRequestReq;
+}
+
+/**
+ * 接受好友请求响应
+ */
+export declare class AcceptFriendRequestResp {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 AcceptFriendRequestResp
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): AcceptFriendRequestResp;
+}
+
+/**
+ * 删除酒友请求（路径参数）
+ */
+export declare class RemoveFriendReq {
+    [key: string]: any;
+    /**
+    * 酒友ID
+    */
+    userId: string|number;
+    
+    /**
+     * @param userId string|number  酒友ID
+     */
+    constructor(userId: string|number,);
+    /**
+     * 从对象创建 RemoveFriendReq
+     *
+     * @param o Object 
+     * - userId: string|number, //  酒友ID
+     */
+    static fromObject(o: Object): RemoveFriendReq;
+}
+
+/**
+ * 删除酒友响应
+ */
+export declare class RemoveFriendResp {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 RemoveFriendResp
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): RemoveFriendResp;
+}
+
+/**
+ * 酒局信息
+ */
+export declare class Event {
+    [key: string]: any;
+    /**
+    * 酒局ID
+    */
+    id: string|number;
+    /**
+    * 酒局标题
+    */
+    title: string;
+    /**
+    * 酒局组织者
+    */
+    organizer: User;
+    /**
+    * 酒局时间
+    */
+    time: string;
+    /**
+    * 酒局地点
+    */
+    location: string;
+    /**
+    * 最大人数
+    */
+    maxPeople: number;
+    /**
+    * 已报名人数
+    */
+    joined: number;
+    /**
+    * 已报名用户
+    */
+    participants: Array<User>;
+    /**
+    * 酒局状态
+    */
+    status: EventStatus;
+    /**
+    * 酒局备注
+    */
+    note: string;
+    /**
+    * 是否已报名
+    */
+    isJoined: boolean;
+    /**
+    * 是否为组织者
+    */
+    isOrganizer: boolean;
+    
+    /**
+     * @param id string|number  酒局ID
+     * @param title string  酒局标题
+     * @param organizer User  酒局组织者
+     * @param time string  酒局时间
+     * @param location string  酒局地点
+     * @param maxPeople number  最大人数
+     * @param joined number  已报名人数
+     * @param participants Array<User>  已报名用户
+     * @param status EventStatus  酒局状态
+     * @param note string  酒局备注
+     * @param isJoined boolean  是否已报名
+     * @param isOrganizer boolean  是否为组织者
+     */
+    constructor(id: string|number,title: string,organizer: User,time: string,location: string,maxPeople: number,joined: number,participants: Array<User>,status: EventStatus,note: string,isJoined: boolean,isOrganizer: boolean,);
+    /**
+     * 从对象创建 Event
+     *
+     * @param o Object 
+     * - id: string|number, //  酒局ID
+     * - title: string, //  酒局标题
+     * - organizer: User, //  酒局组织者
+     * - time: string, //  酒局时间
+     * - location: string, //  酒局地点
+     * - maxPeople: number, //  最大人数
+     * - joined: number, //  已报名人数
+     * - participants: Array<User>, //  已报名用户
+     * - status: EventStatus, //  酒局状态
+     * - note: string, //  酒局备注
+     * - isJoined: boolean, //  是否已报名
+     * - isOrganizer: boolean, //  是否为组织者
+     */
+    static fromObject(o: Object): Event;
+}
+
+/**
+ * 酒局列表响应
+ */
+export declare class EventListData {
+    [key: string]: any;
+    /**
+    * 分页数据
+    */
+    list: Array<Event>;
+    
+    /**
+     * @param list Array<Event>  分页数据
+     */
+    constructor(list: Array<Event>,);
+    /**
+     * 从对象创建 EventListData
+     *
+     * @param o Object 
+     * - list: Array<Event>, //  分页数据
+     */
+    static fromObject(o: Object): EventListData;
+}
+
+/**
+ * 获取酒局列表请求
+ */
+export declare class GetEventsReq {
+    [key: string]: any;
+    /**
+    * 状态筛选
+    */
+    status: EventStatus;
+    
+    /**
+     * @param status EventStatus  状态筛选
+     */
+    constructor(status: EventStatus,);
+    /**
+     * 从对象创建 GetEventsReq
+     *
+     * @param o Object 
+     * - status: EventStatus, //  状态筛选
+     */
+    static fromObject(o: Object): GetEventsReq;
+}
+
+/**
+ * 获取酒局详情请求（路径参数）
+ */
+export declare class GetEventDetailReq {
+    [key: string]: any;
+    /**
+    * 酒局ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  酒局ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 GetEventDetailReq
+     *
+     * @param o Object 
+     * - id: string|number, //  酒局ID
+     */
+    static fromObject(o: Object): GetEventDetailReq;
+}
+
+/**
+ * 坐标信息
+ */
+export declare class GeoPoint {
+    [key: string]: any;
+    /**
+    * 纬度
+    */
+    latitude: number;
+    /**
+    * 经度
+    */
+    longitude: number;
+    
+    /**
+     * @param latitude number  纬度
+     * @param longitude number  经度
+     */
+    constructor(latitude: number,longitude: number,);
+    /**
+     * 从对象创建 GeoPoint
+     *
+     * @param o Object 
+     * - latitude: number, //  纬度
+     * - longitude: number, //  经度
+     */
+    static fromObject(o: Object): GeoPoint;
+}
+
+/**
+ * 发起酒局请求
+ */
+export declare class CreateEventReq {
+    [key: string]: any;
+    /**
+    * 酒局标题
+    */
+    title: string;
+    /**
+    * 酒局时间
+    */
+    time: string;
+    /**
+    * 酒局地点
+    */
+    location: string;
+    /**
+    * 最大人数
+    */
+    maxPeople: number;
+    /**
+    * 坐标信息
+    */
+    geo: GeoPoint;
+    /**
+    * 酒局备注
+    */
+    note: string;
+    
+    /**
+     * @param title string  酒局标题
+     * @param time string  酒局时间
+     * @param location string  酒局地点
+     * @param maxPeople number  最大人数
+     * @param geo GeoPoint  坐标信息
+     * @param note string  酒局备注
+     */
+    constructor(title: string,time: string,location: string,maxPeople: number,geo: GeoPoint,note: string,);
+    /**
+     * 从对象创建 CreateEventReq
+     *
+     * @param o Object 
+     * - title: string, //  酒局标题
+     * - time: string, //  酒局时间
+     * - location: string, //  酒局地点
+     * - maxPeople: number, //  最大人数
+     * - geo: GeoPoint, //  坐标信息
+     * - note: string, //  酒局备注
+     */
+    static fromObject(o: Object): CreateEventReq;
+}
+
+/**
+ * 发起酒局响应
+ */
+export declare class CreateEventResp {
+    [key: string]: any;
+    /**
+    * 酒局ID
+    */
+    eventId: string|number;
+    
+    /**
+     * @param eventId string|number  酒局ID
+     */
+    constructor(eventId: string|number,);
+    /**
+     * 从对象创建 CreateEventResp
+     *
+     * @param o Object 
+     * - eventId: string|number, //  酒局ID
+     */
+    static fromObject(o: Object): CreateEventResp;
+}
+
+/**
+ * 报名/取消/签到请求（路径参数）
+ */
+export declare class JoinEventReq {
+    [key: string]: any;
+    /**
+    * 酒局ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  酒局ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 JoinEventReq
+     *
+     * @param o Object 
+     * - id: string|number, //  酒局ID
+     */
+    static fromObject(o: Object): JoinEventReq;
+}
+
+/**
+ * 
+ */
+export declare class JoinEventResp {
+    [key: string]: any;
+    /**
+    * 是否成功
+    */
+    ok: boolean;
+    
+    /**
+     * @param ok boolean  是否成功
+     */
+    constructor(ok: boolean,);
+    /**
+     * 从对象创建 JoinEventResp
+     *
+     * @param o Object 
+     * - ok: boolean, //  是否成功
+     */
+    static fromObject(o: Object): JoinEventResp;
+}
+
+/**
+ * 
+ */
+export declare class QuitEventReq {
+    [key: string]: any;
+    /**
+    * 酒局ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  酒局ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 QuitEventReq
+     *
+     * @param o Object 
+     * - id: string|number, //  酒局ID
+     */
+    static fromObject(o: Object): QuitEventReq;
+}
+
+/**
+ * 
+ */
+export declare class QuitEventResp {
+    [key: string]: any;
+    /**
+    * 是否成功
+    */
+    ok: boolean;
+    
+    /**
+     * @param ok boolean  是否成功
+     */
+    constructor(ok: boolean,);
+    /**
+     * 从对象创建 QuitEventResp
+     *
+     * @param o Object 
+     * - ok: boolean, //  是否成功
+     */
+    static fromObject(o: Object): QuitEventResp;
+}
+
+/**
+ * 
+ */
+export declare class CheckInEventReq {
+    [key: string]: any;
+    /**
+    * 酒局ID
+    */
+    id: string|number;
+    
+    /**
+     * @param id string|number  酒局ID
+     */
+    constructor(id: string|number,);
+    /**
+     * 从对象创建 CheckInEventReq
+     *
+     * @param o Object 
+     * - id: string|number, //  酒局ID
+     */
+    static fromObject(o: Object): CheckInEventReq;
+}
+
+/**
+ * 
+ */
+export declare class CheckInEventResp {
+    [key: string]: any;
+    /**
+    * 是否成功
+    */
+    ok: boolean;
+    
+    /**
+     * @param ok boolean  是否成功
+     */
+    constructor(ok: boolean,);
+    /**
+     * 从对象创建 CheckInEventResp
+     *
+     * @param o Object 
+     * - ok: boolean, //  是否成功
+     */
+    static fromObject(o: Object): CheckInEventResp;
+}
+
+/**
+ * 会话信息
+ */
+export declare class Conversation {
+    [key: string]: any;
+    /**
+    * 会话ID
+    */
+    id: string;
+    /**
+    * 对方用户ID
+    */
+    friendId: string|number;
+    /**
+    * 对方昵称
+    */
+    nickname: string;
+    /**
+    * 对方头像URL（可为空）
+    */
+    avatar: string;
+    /**
+    * 最后一条消息摘要
+    */
+    lastMessage: string;
+    /**
+    * 最后消息时间（ISO 8601）
+    */
+    lastTime: string;
+    /**
+    * 未读消息数
+    */
+    unread: number;
+    /**
+    * 对方是否在线
+    */
+    online: boolean;
+    
+    /**
+     * @param id string  会话ID
+     * @param friendId string|number  对方用户ID
+     * @param nickname string  对方昵称
+     * @param avatar string  对方头像URL（可为空）
+     * @param lastMessage string  最后一条消息摘要
+     * @param lastTime string  最后消息时间（ISO 8601）
+     * @param unread number  未读消息数
+     * @param online boolean  对方是否在线
+     */
+    constructor(id: string,friendId: string|number,nickname: string,avatar: string,lastMessage: string,lastTime: string,unread: number,online: boolean,);
+    /**
+     * 从对象创建 Conversation
+     *
+     * @param o Object 
+     * - id: string, //  会话ID
+     * - friendId: string|number, //  对方用户ID
+     * - nickname: string, //  对方昵称
+     * - avatar: string, //  对方头像URL（可为空）
+     * - lastMessage: string, //  最后一条消息摘要
+     * - lastTime: string, //  最后消息时间（ISO 8601）
+     * - unread: number, //  未读消息数
+     * - online: boolean, //  对方是否在线
+     */
+    static fromObject(o: Object): Conversation;
+}
+
+/**
+ * 
+ */
+export declare class GetConversationsReq {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 GetConversationsReq
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): GetConversationsReq;
+}
+
+/**
+ * 获取会话列表响应
+ */
+export declare class GetConversationsResp {
+    [key: string]: any;
+    /**
+    * 会话列表
+    */
+    list: Array<Conversation>;
+    
+    /**
+     * @param list Array<Conversation>  会话列表
+     */
+    constructor(list: Array<Conversation>,);
+    /**
+     * 从对象创建 GetConversationsResp
+     *
+     * @param o Object 
+     * - list: Array<Conversation>, //  会话列表
+     */
+    static fromObject(o: Object): GetConversationsResp;
+}
+
+/**
+ * 获取历史消息请求
+ */
+export declare class GetMessagesReq {
+    [key: string]: any;
+    /**
+    * 会话ID
+    */
+    conversationId: string;
+    /**
+    * 游标分页
+    */
+    lastID: string|number;
+    /**
+    * 每页数量，默认20
+    */
+    pageSize: number;
+    
+    /**
+     * @param conversationId string  会话ID
+     * @param lastID string|number  游标分页
+     * @param pageSize number  每页数量，默认20
+     */
+    constructor(conversationId: string,lastID: string|number,pageSize: number,);
+    /**
+     * 从对象创建 GetMessagesReq
+     *
+     * @param o Object 
+     * - conversationId: string, //  会话ID
+     * - lastID: string|number, //  游标分页
+     * - pageSize: number, //  每页数量，默认20
+     */
+    static fromObject(o: Object): GetMessagesReq;
+}
+
+/**
+ * 消息记录
+ */
+export declare class Message {
+    [key: string]: any;
+    /**
+    * 消息ID
+    */
+    id: string|number;
+    /**
+    * 会话ID
+    */
+    conversationId: string;
+    /**
+    * 发送者ID
+    */
+    senderId: string|number;
+    /**
+    * 接收者ID
+    */
+    receiverId: string|number;
+    /**
+    * 消息类型
+    */
+    type: MessageType;
+    /**
+    * 消息内容
+    */
+    content: string;
+    /**
+    * 发送时间（毫秒时间戳）
+    */
+    timestamp: number;
+    /**
+    * 消息状态
+    */
+    status: MessageStatus;
+    
+    /**
+     * @param id string|number  消息ID
+     * @param conversationId string  会话ID
+     * @param senderId string|number  发送者ID
+     * @param receiverId string|number  接收者ID
+     * @param type MessageType  消息类型
+     * @param content string  消息内容
+     * @param timestamp number  发送时间（毫秒时间戳）
+     * @param status MessageStatus  消息状态
+     */
+    constructor(id: string|number,conversationId: string,senderId: string|number,receiverId: string|number,type: MessageType,content: string,timestamp: number,status: MessageStatus,);
+    /**
+     * 从对象创建 Message
+     *
+     * @param o Object 
+     * - id: string|number, //  消息ID
+     * - conversationId: string, //  会话ID
+     * - senderId: string|number, //  发送者ID
+     * - receiverId: string|number, //  接收者ID
+     * - type: MessageType, //  消息类型
+     * - content: string, //  消息内容
+     * - timestamp: number, //  发送时间（毫秒时间戳）
+     * - status: MessageStatus, //  消息状态
+     */
+    static fromObject(o: Object): Message;
+}
+
+/**
+ * 获取历史消息响应
+ */
+export declare class GetMessagesResp {
+    [key: string]: any;
+    /**
+    * 消息列表
+    */
+    list: Array<Message>;
+    /**
+    * 是否还有更多消息
+    */
+    hasMore: boolean;
+    
+    /**
+     * @param list Array<Message>  消息列表
+     * @param hasMore boolean  是否还有更多消息
+     */
+    constructor(list: Array<Message>,hasMore: boolean,);
+    /**
+     * 从对象创建 GetMessagesResp
+     *
+     * @param o Object 
+     * - list: Array<Message>, //  消息列表
+     * - hasMore: boolean, //  是否还有更多消息
+     */
+    static fromObject(o: Object): GetMessagesResp;
+}
+
+/**
+ * 标记已读请求（路径参数）
+ */
+export declare class MarkReadReq {
+    [key: string]: any;
+    /**
+    * 会话ID（路径参数）
+    */
+    id: string;
+    
+    /**
+     * @param id string  会话ID（路径参数）
+     */
+    constructor(id: string,);
+    /**
+     * 从对象创建 MarkReadReq
+     *
+     * @param o Object 
+     * - id: string, //  会话ID（路径参数）
+     */
+    static fromObject(o: Object): MarkReadReq;
+}
+
+/**
+ * 标记已读响应
+ */
+export declare class MarkReadResp {
+    [key: string]: any;
+    /**
+    * 是否成功
+    */
+    success: boolean;
+    
+    /**
+     * @param success boolean  是否成功
+     */
+    constructor(success: boolean,);
+    /**
+     * 从对象创建 MarkReadResp
+     *
+     * @param o Object 
+     * - success: boolean, //  是否成功
+     */
+    static fromObject(o: Object): MarkReadResp;
+}
+
+/**
+ * 
+ */
+export declare class GetUnreadCountReq {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 GetUnreadCountReq
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): GetUnreadCountReq;
+}
+
+/**
+ * 获取未读总数响应
+ */
+export declare class GetUnreadCountResp {
+    [key: string]: any;
+    /**
+    * 未读总数
+    */
+    total: number;
+    
+    /**
+     * @param total number  未读总数
+     */
+    constructor(total: number,);
+    /**
+     * 从对象创建 GetUnreadCountResp
+     *
+     * @param o Object 
+     * - total: number, //  未读总数
+     */
+    static fromObject(o: Object): GetUnreadCountResp;
+}
+
+/**
+ * 客户端 - 发送聊天数据
+ */
+export declare class ClientChatData {
+    [key: string]: any;
+    /**
+    * 接收者ID
+    */
+    receiverId: string|number;
+    /**
+    * 消息内容
+    */
+    content: string;
+    /**
+    * 消息类型
+    */
+    msgType: MessageType;
+    /**
+    * 客户端消息ID
+    */
+    clientMesgId: string|number;
+    
+    /**
+     * @param receiverId string|number  接收者ID
+     * @param content string  消息内容
+     * @param msgType MessageType  消息类型
+     * @param clientMesgId string|number  客户端消息ID
+     */
+    constructor(receiverId: string|number,content: string,msgType: MessageType,clientMesgId: string|number,);
+    /**
+     * 从对象创建 ClientChatData
+     *
+     * @param o Object 
+     * - receiverId: string|number, //  接收者ID
+     * - content: string, //  消息内容
+     * - msgType: MessageType, //  消息类型
+     * - clientMesgId: string|number, //  客户端消息ID
+     */
+    static fromObject(o: Object): ClientChatData;
+}
+
+/**
+ * 客户端 - 输入状态数据
+ */
+export declare class ClientTypingData {
+    [key: string]: any;
+    /**
+    * 接收者ID
+    */
+    receiverId: string|number;
+    
+    /**
+     * @param receiverId string|number  接收者ID
+     */
+    constructor(receiverId: string|number,);
+    /**
+     * 从对象创建 ClientTypingData
+     *
+     * @param o Object 
+     * - receiverId: string|number, //  接收者ID
+     */
+    static fromObject(o: Object): ClientTypingData;
+}
+
+/**
+ * 客户端 - 已读回执数据
+ */
+export declare class ClientReadData {
+    [key: string]: any;
+    /**
+    * 会话ID
+    */
+    conversationId: string;
+    /**
+    * 最后一条消息ID
+    */
+    lastMsgId: string|number;
+    
+    /**
+     * @param conversationId string  会话ID
+     * @param lastMsgId string|number  最后一条消息ID
+     */
+    constructor(conversationId: string,lastMsgId: string|number,);
+    /**
+     * 从对象创建 ClientReadData
+     *
+     * @param o Object 
+     * - conversationId: string, //  会话ID
+     * - lastMsgId: string|number, //  最后一条消息ID
+     */
+    static fromObject(o: Object): ClientReadData;
+}
+
+/**
+ * 客户端 - ping 数据（空）
+ */
+export declare class ClientPingData {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 ClientPingData
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): ClientPingData;
+}
+
+/**
+ * 服务端 - 推送聊天数据
+ */
+export declare class ServerChatData {
+    [key: string]: any;
+    /**
+    * 消息ID
+    */
+    msgId: string|number;
+    /**
+    * 发送者ID
+    */
+    senderId: string|number;
+    /**
+    * 接收者ID
+    */
+    receiverId: string|number;
+    /**
+    * 会话ID
+    */
+    conversationId: string;
+    /**
+    * 消息内容
+    */
+    content: string;
+    /**
+    * 消息类型
+    */
+    msgType: MessageType;
+    /**
+    * 发送时间（毫秒时间戳）
+    */
+    timestamp: number;
+    
+    /**
+     * @param msgId string|number  消息ID
+     * @param senderId string|number  发送者ID
+     * @param receiverId string|number  接收者ID
+     * @param conversationId string  会话ID
+     * @param content string  消息内容
+     * @param msgType MessageType  消息类型
+     * @param timestamp number  发送时间（毫秒时间戳）
+     */
+    constructor(msgId: string|number,senderId: string|number,receiverId: string|number,conversationId: string,content: string,msgType: MessageType,timestamp: number,);
+    /**
+     * 从对象创建 ServerChatData
+     *
+     * @param o Object 
+     * - msgId: string|number, //  消息ID
+     * - senderId: string|number, //  发送者ID
+     * - receiverId: string|number, //  接收者ID
+     * - conversationId: string, //  会话ID
+     * - content: string, //  消息内容
+     * - msgType: MessageType, //  消息类型
+     * - timestamp: number, //  发送时间（毫秒时间戳）
+     */
+    static fromObject(o: Object): ServerChatData;
+}
+
+/**
+ * 服务端 - 推送输入状态数据
+ */
+export declare class ServerTypingData {
+    [key: string]: any;
+    /**
+    * 发送者ID
+    */
+    senderId: string|number;
+    
+    /**
+     * @param senderId string|number  发送者ID
+     */
+    constructor(senderId: string|number,);
+    /**
+     * 从对象创建 ServerTypingData
+     *
+     * @param o Object 
+     * - senderId: string|number, //  发送者ID
+     */
+    static fromObject(o: Object): ServerTypingData;
+}
+
+/**
+ * 服务端 - 推送已读回执数据
+ */
+export declare class ServerReadData {
+    [key: string]: any;
+    /**
+    * 会话ID
+    */
+    conversationId: string;
+    /**
+    * 读取者ID
+    */
+    readerId: string|number;
+    
+    /**
+     * @param conversationId string  会话ID
+     * @param readerId string|number  读取者ID
+     */
+    constructor(conversationId: string,readerId: string|number,);
+    /**
+     * 从对象创建 ServerReadData
+     *
+     * @param o Object 
+     * - conversationId: string, //  会话ID
+     * - readerId: string|number, //  读取者ID
+     */
+    static fromObject(o: Object): ServerReadData;
+}
+
+/**
+ * 服务端 - ACK 数据
+ */
+export declare class ServerAckData {
+    [key: string]: any;
+    /**
+    * 客户端消息ID
+    */
+    clientMsgId: string|number;
+    /**
+    * 消息ID
+    */
+    msgId: string|number;
+    /**
+    * 消息状态
+    */
+    status: MessageStatus;
+    
+    /**
+     * @param clientMsgId string|number  客户端消息ID
+     * @param msgId string|number  消息ID
+     * @param status MessageStatus  消息状态
+     */
+    constructor(clientMsgId: string|number,msgId: string|number,status: MessageStatus,);
+    /**
+     * 从对象创建 ServerAckData
+     *
+     * @param o Object 
+     * - clientMsgId: string|number, //  客户端消息ID
+     * - msgId: string|number, //  消息ID
+     * - status: MessageStatus, //  消息状态
+     */
+    static fromObject(o: Object): ServerAckData;
+}
+
+/**
+ * 服务端 - pong 数据（空）
+ */
+export declare class ServerPongData {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 ServerPongData
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): ServerPongData;
+}
+
+/**
+ * 服务端 - 连接成功数据
+ */
+export declare class ServerConnectedData {
+    [key: string]: any;
+    /**
+    * 用户ID
+    */
+    userId: string|number;
+    
+    /**
+     * @param userId string|number  用户ID
+     */
+    constructor(userId: string|number,);
+    /**
+     * 从对象创建 ServerConnectedData
+     *
+     * @param o Object 
+     * - userId: string|number, //  用户ID
+     */
+    static fromObject(o: Object): ServerConnectedData;
+}
+
+/**
+ * 服务端 - 被踢下线数据（空）
+ */
+export declare class ServerKickedData {
+    [key: string]: any;
+    
+    /**
+     */
+    constructor();
+    /**
+     * 从对象创建 ServerKickedData
+     *
+     * @param o Object 
+     */
+    static fromObject(o: Object): ServerKickedData;
+}
+
+/**
+ * 
+ */
+export declare class ChatWebSocket {
+    [key: string]: any;
+    /**
+    * 消息类型
+    */
+    mesgType: ClientMesgType;
+    /**
+    * 消息数据
+    */
+    data: ClientMessage;
+    
+    /**
+     * @param mesgType ClientMesgType  消息类型
+     * @param data ClientMessage  消息数据
+     */
+    constructor(mesgType: ClientMesgType,data: ClientMessage,);
+    /**
+     * 从对象创建 ChatWebSocket
+     *
+     * @param o Object 
+     * - mesgType: ClientMesgType, //  消息类型
+     * - data: ClientMessage, //  消息数据
+     */
+    static fromObject(o: Object): ChatWebSocket;
+}
+
+/**
+ * WebSocket 响应
+ */
+export declare class ChatWebSocketResp {
+    [key: string]: any;
+    /**
+    * 消息类型
+    */
+    mesgType: ServerMesgType;
+    /**
+    * 消息数据
+    */
+    data: ServerMessage;
+    
+    /**
+     * @param mesgType ServerMesgType  消息类型
+     * @param data ServerMessage  消息数据
+     */
+    constructor(mesgType: ServerMesgType,data: ServerMessage,);
+    /**
+     * 从对象创建 ChatWebSocketResp
+     *
+     * @param o Object 
+     * - mesgType: ServerMesgType, //  消息类型
+     * - data: ServerMessage, //  消息数据
+     */
+    static fromObject(o: Object): ChatWebSocketResp;
+}
+
+export type ClientMessage = ClientChatData | ClientTypingData | ClientReadData | ClientPingData | null 
+export type ServerMessage = ServerChatData | ServerTypingData | ServerReadData | ServerAckData | ServerPongData | ServerConnectedData | ServerKickedData | null 
+
+export class ChatWebSocketConn {
+    constructor(host: string);
+    public backoff(attempt: number): number;
+    public connect(): void;
+    public onopen(event: Event): void;
+    public onmessage(event: MessageEvent): void;
+    public onServerChatData(data: ServerChatData): void;
+    public writeServerChatData(data: ServerChatData): void;
+    public onServerTypingData(data: ServerTypingData): void;
+    public writeServerTypingData(data: ServerTypingData): void;
+    public onServerReadData(data: ServerReadData): void;
+    public writeServerReadData(data: ServerReadData): void;
+    public onServerAckData(data: ServerAckData): void;
+    public writeServerAckData(data: ServerAckData): void;
+    public onServerPongData(data: ServerPongData): void;
+    public writeServerPongData(data: ServerPongData): void;
+    public onServerConnectedData(data: ServerConnectedData): void;
+    public writeServerConnectedData(data: ServerConnectedData): void;
+    public onServerKickedData(data: ServerKickedData): void;
+    public writeServerKickedData(data: ServerKickedData): void;
+    public onclose(event: CloseEvent): void;
+    public onerror(event: ErrorEvent): void;
+    public close(): void;
+}
 
 /**
  * * 喝酒了么 - 后端接口 API
@@ -2650,22 +4711,6 @@ export default class HaveADrink {
      */
     public GetFeed(req: GetFeedReq) : Promise<GetFeedResp>;
     
-    /**
-     * 点赞
-     *
-     * @param req LikeRecordReq 点赞/取消点赞请求
-     * @return LikeRecordResp 点赞/取消点赞响应
-     */
-    public LikeRecord(req: LikeRecordReq) : Promise<LikeRecordResp>;
-    
-    /**
-     * 取消点赞
-     *
-     * @param req LikeRecordReq 点赞/取消点赞请求
-     * @return LikeRecordResp 点赞/取消点赞响应
-     */
-    public UnlikeRecord(req: LikeRecordReq) : Promise<LikeRecordResp>;
-    
     /**
      * 上传照片
      *
@@ -2770,4 +4815,180 @@ export default class HaveADrink {
      */
     public UploadImage(req: UploadImageReq) : Promise<UploadImageResp>;
     
+    /**
+     * 动态信息流
+     *
+     * @param req GetFeedsReq 获取酒友圈动态请求
+     * @return GetFeedsResp 动态列表响应
+     */
+    public GetFeeds(req: GetFeedsReq) : Promise<GetFeedsResp>;
+    
+    /**
+     * 发布动态
+     *
+     * @param req PublishFeedReq 发布动态请求
+     * @return PublishFeedResp 发布动态响应
+     */
+    public PublishFeed(req: PublishFeedReq) : Promise<PublishFeedResp>;
+    
+    /**
+     * 点赞
+     *
+     * @param req LikeFeedReq 点赞/取消点赞请求（路径参数）
+     * @return LikeFeedResp 点赞响应
+     */
+    public LikeFeed(req: LikeFeedReq) : Promise<LikeFeedResp>;
+    
+    /**
+     * 取消点赞
+     *
+     * @param req UnlikeFeedReq 
+     * @return UnlikeFeedResp 取消点赞响应
+     */
+    public UnlikeFeed(req: UnlikeFeedReq) : Promise<UnlikeFeedResp>;
+    
+    /**
+     * 获取评论
+     *
+     * @param req GetFeedCommentsReq 获取评论请求（路径参数）
+     * @return CommentListData 评论列表响应
+     */
+    public GetFeedComments(req: GetFeedCommentsReq) : Promise<CommentListData>;
+    
+    /**
+     * 发表评论
+     *
+     * @param req AddCommentFullReq 发表评论请求（含路径参数）
+     * @return AddCommentResp 发表评论响应
+     */
+    public AddComment(req: AddCommentFullReq) : Promise<AddCommentResp>;
+    
+    /**
+     * 酒友管理
+     *
+     * @param req GetFriendsReq 获取酒友列表请求
+     * @return GetFriendRequestsResp 酒友列表响应
+     */
+    public GetFriends(req: GetFriendsReq) : Promise<GetFriendRequestsResp>;
+    
+    /**
+     * 好友请求管理
+     *
+     * @param req GetFriendRequestsReq 获取好友请求列表请求
+     * @return FriendRequestListData 好友请求列表响应
+     */
+    public GetFriendRequests(req: GetFriendRequestsReq) : Promise<FriendRequestListData>;
+    
+    /**
+     * 发送好友请求
+     *
+     * @param req SendFriendRequestReq 发送好友请求
+     * @return SendFriendRequestResp 发送好友请求响应
+     */
+    public SendFriendRequest(req: SendFriendRequestReq) : Promise<SendFriendRequestResp>;
+    
+    /**
+     * 接受好友请求
+     *
+     * @param req AcceptFriendRequestReq 接受好友请求（路径参数）
+     * @return AcceptFriendRequestResp 接受好友请求响应
+     */
+    public AcceptFriendRequest(req: AcceptFriendRequestReq) : Promise<AcceptFriendRequestResp>;
+    
+    /**
+     * 删除酒友
+     *
+     * @param req RemoveFriendReq 删除酒友请求（路径参数）
+     * @return RemoveFriendResp 删除酒友响应
+     */
+    public RemoveFriend(req: RemoveFriendReq) : Promise<RemoveFriendResp>;
+    
+    /**
+     * 约酒活动
+     *
+     * @param req GetEventsReq 获取酒局列表请求
+     * @return EventListData 酒局列表响应
+     */
+    public GetEvents(req: GetEventsReq) : Promise<EventListData>;
+    
+    /**
+     * 获取酒局详情
+     *
+     * @param req GetEventDetailReq 获取酒局详情请求（路径参数）
+     * @return Event 酒局信息
+     */
+    public GetEventDetail(req: GetEventDetailReq) : Promise<Event>;
+    
+    /**
+     * 发起酒局
+     *
+     * @param req CreateEventReq 发起酒局请求
+     * @return CreateEventResp 发起酒局响应
+     */
+    public CreateEvent(req: CreateEventReq) : Promise<CreateEventResp>;
+    
+    /**
+     * 报名酒局
+     *
+     * @param req JoinEventReq 报名/取消/签到请求（路径参数）
+     * @return JoinEventResp 
+     */
+    public JoinEvent(req: JoinEventReq) : Promise<JoinEventResp>;
+    
+    /**
+     * 取消报名酒局
+     *
+     * @param req QuitEventReq 
+     * @return QuitEventResp 
+     */
+    public QuitEvent(req: QuitEventReq) : Promise<QuitEventResp>;
+    
+    /**
+     * 签到酒局
+     *
+     * @param req CheckInEventReq 
+     * @return CheckInEventResp 
+     */
+    public CheckInEvent(req: CheckInEventReq) : Promise<CheckInEventResp>;
+    
+    /**
+     * 获取会话列表
+     *
+     * @param req GetConversationsReq 
+     * @return GetConversationsResp 获取会话列表响应
+     */
+    public GetConversations(req: GetConversationsReq) : Promise<GetConversationsResp>;
+    
+    /**
+     * 获取历史消息
+     *
+     * @param req GetMessagesReq 获取历史消息请求
+     * @return GetMessagesResp 获取历史消息响应
+     */
+    public GetMessages(req: GetMessagesReq) : Promise<GetMessagesResp>;
+    
+    /**
+     * 标记会话已读
+     *
+     * @param req MarkReadReq 标记已读请求（路径参数）
+     * @return MarkReadResp 标记已读响应
+     */
+    public MarkRead(req: MarkReadReq) : Promise<MarkReadResp>;
+    
+    /**
+     * 获取未读消息总数
+     *
+     * @param req GetUnreadCountReq 
+     * @return GetUnreadCountResp 获取未读总数响应
+     */
+    public GetUnreadCount(req: GetUnreadCountReq) : Promise<GetUnreadCountResp>;
+    
+    /**
+     * 注意：连接建立后，服务端会先验证 token，然后推送 connected 事件
+     *
+     * @param req ChatWebSocket 
+     * @return ChatWebSocketConn
+     */
+    public ChatWebSocket() : ChatWebSocketConn;
+    
 }
diff --git a/node_modules/HaveADrink/index.js b/node_modules/HaveADrink/index.js
index d130d35..c490464 100644
--- a/node_modules/HaveADrink/index.js
+++ b/node_modules/HaveADrink/index.js
@@ -395,6 +395,207 @@ export class Frequency {
     }
 }
 
+/**
+ * 酒局状态
+ */
+export class EventStatus {
+    /**
+     * 开放报名
+     */
+    static Open = 1;
+    /**
+     * 待开始
+     */
+    static Upcoming = 2;
+    /**
+     * 进行中
+     */
+    static Ongoing = 3;
+    /**
+     * 已结束
+     */
+    static Ended = 4;
+
+    static entries() {
+        return [
+            { value: EventStatus.Open, label: '开放报名' },
+            { value: EventStatus.Upcoming, label: '待开始' },
+            { value: EventStatus.Ongoing, label: '进行中' },
+            { value: EventStatus.Ended, label: '已结束' },
+        ];
+    }
+    static getLabel(v) {
+        switch(v) { 
+        case EventStatus.Open: return '开放报名';
+        case EventStatus.Upcoming: return '待开始';
+        case EventStatus.Ongoing: return '进行中';
+        case EventStatus.Ended: return '已结束';
+        }
+    }
+}
+
+/**
+ * 消息类型（文本/图片）
+ */
+export class MessageType {
+    /**
+     * 文本消息
+     */
+    static Text = "text";
+    /**
+     * 图片消息
+     */
+    static Image = "image";
+
+    static entries() {
+        return [
+            { value: MessageType.Text, label: '文本消息' },
+            { value: MessageType.Image, label: '图片消息' },
+        ];
+    }
+    static getLabel(v) {
+        switch(v) { 
+        case MessageType.Text: return '文本消息';
+        case MessageType.Image: return '图片消息';
+        }
+    }
+}
+
+/**
+ * 消息状态（发送、送达、已读）
+ */
+export class MessageStatus {
+    /**
+     * 发送中
+     */
+    static Sending = "sending";
+    /**
+     * 已发送
+     */
+    static Sent = "sent";
+    /**
+     * 已送达
+     */
+    static Delivered = "delivered";
+    /**
+     * 已读
+     */
+    static Read = "read";
+
+    static entries() {
+        return [
+            { value: MessageStatus.Sending, label: '发送中' },
+            { value: MessageStatus.Sent, label: '已发送' },
+            { value: MessageStatus.Delivered, label: '已送达' },
+            { value: MessageStatus.Read, label: '已读' },
+        ];
+    }
+    static getLabel(v) {
+        switch(v) { 
+        case MessageStatus.Sending: return '发送中';
+        case MessageStatus.Sent: return '已发送';
+        case MessageStatus.Delivered: return '已送达';
+        case MessageStatus.Read: return '已读';
+        }
+    }
+}
+
+/**
+ * 客户端 WebSocket 消息类型
+ */
+export class ClientMesgType {
+    /**
+     * 发送消息
+     */
+    static Chat = "chat";
+    /**
+     * 输入状态
+     */
+    static Typing = "typing";
+    /**
+     * 已读回执
+     */
+    static Read = "read";
+    /**
+     * 心跳
+     */
+    static Ping = "ping";
+
+    static entries() {
+        return [
+            { value: ClientMesgType.Chat, label: '发送消息' },
+            { value: ClientMesgType.Typing, label: '输入状态' },
+            { value: ClientMesgType.Read, label: '已读回执' },
+            { value: ClientMesgType.Ping, label: '心跳' },
+        ];
+    }
+    static getLabel(v) {
+        switch(v) { 
+        case ClientMesgType.Chat: return '发送消息';
+        case ClientMesgType.Typing: return '输入状态';
+        case ClientMesgType.Read: return '已读回执';
+        case ClientMesgType.Ping: return '心跳';
+        }
+    }
+}
+
+/**
+ * 服务端 WebSocket 消息类型
+ */
+export class ServerMesgType {
+    /**
+     * 推送新消息
+     */
+    static Chat = "chat";
+    /**
+     * 对方输入状态
+     */
+    static Typing = "typing";
+    /**
+     * 对方已读回执
+     */
+    static Read = "read";
+    /**
+     * 消息送达确认
+     */
+    static Ack = "ack";
+    /**
+     * 心跳响应
+     */
+    static Pong = "pong";
+    /**
+     * 连接成功
+     */
+    static Connected = "connected";
+    /**
+     * 被踢下线
+     */
+    static Kicked = "kicked";
+
+    static entries() {
+        return [
+            { value: ServerMesgType.Chat, label: '推送新消息' },
+            { value: ServerMesgType.Typing, label: '对方输入状态' },
+            { value: ServerMesgType.Read, label: '对方已读回执' },
+            { value: ServerMesgType.Ack, label: '消息送达确认' },
+            { value: ServerMesgType.Pong, label: '心跳响应' },
+            { value: ServerMesgType.Connected, label: '连接成功' },
+            { value: ServerMesgType.Kicked, label: '被踢下线' },
+        ];
+    }
+    static getLabel(v) {
+        switch(v) { 
+        case ServerMesgType.Chat: return '推送新消息';
+        case ServerMesgType.Typing: return '对方输入状态';
+        case ServerMesgType.Read: return '对方已读回执';
+        case ServerMesgType.Ack: return '消息送达确认';
+        case ServerMesgType.Pong: return '心跳响应';
+        case ServerMesgType.Connected: return '连接成功';
+        case ServerMesgType.Kicked: return '被踢下线';
+        }
+    }
+}
+
 /**
  * 手机号
  */
@@ -464,6 +665,20 @@ export class Ok {
     }
 }
 
+/**
+ * 用于表示无数据
+ */
+export class None {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new None();
+    }
+}
+
 /**
  * 微信登录请求参数
  */
@@ -796,36 +1011,6 @@ export class FeedPageData {
     }
 }
 
-/**
- * 点赞/取消点赞请求
- */
-export class LikeRecordReq {
-    /**
-     * @param id: string|number  记录ID
-     */
-    constructor(id,) {
-        this.id = id;
-        
-    }
-    static fromObject(o) {
-        return new LikeRecordReq(o.id,);
-    }
-}
-
-/**
- * 点赞/取消点赞响应
- */
-export class LikeRecordResp {
-    /**
-     */
-    constructor() {
-        
-    }
-    static fromObject(o) {
-        return new LikeRecordResp();
-    }
-}
-
 /**
  * 上传照片请求
  */
@@ -902,8 +1087,10 @@ export class DrinkItem {
      * @param unit: Unit  单位
      * @param degree: number  酒精度数(%)
      * @param standardCups: number  标准杯数（前端计算，后端应校验）
+     * @param customAmount: number  自定义饮酒数量
+     * @param customUnit: Unit  自定义饮酒单位
      */
-    constructor(category,brand,product,amount,unit,degree,standardCups,) {
+    constructor(category,brand,product,amount,unit,degree,standardCups,customAmount,customUnit,) {
         this.category = category;
         this.brand = brand;
         this.product = product;
@@ -911,10 +1098,12 @@ export class DrinkItem {
         this.unit = unit;
         this.degree = degree;
         this.standardCups = standardCups;
+        this.customAmount = customAmount;
+        this.customUnit = customUnit;
         
     }
     static fromObject(o) {
-        return new DrinkItem(o.category,o.brand,o.product,o.amount,o.unit,o.degree,o.standardCups,);
+        return new DrinkItem(o.category,o.brand,o.product,o.amount,o.unit,o.degree,o.standardCups,o.customAmount,o.customUnit,);
     }
 }
 
@@ -1627,20 +1816,18 @@ export class UploadImageResp {
  */
 export class ReferenceFileReq {
     /**
-     * @param project: string  项目名称
      * @param module: string  模块名称
      * @param data: number  数据 id
      * @param urls: Array<string>  文件 urls
      */
-    constructor(project,module,data,urls,) {
-        this.project = project;
+    constructor(module,data,urls,) {
         this.module = module;
         this.data = data;
         this.urls = urls;
         
     }
     static fromObject(o) {
-        return new ReferenceFileReq(o.project,o.module,o.data,o.urls,);
+        return new ReferenceFileReq(o.module,o.data,o.urls,);
     }
 }
 
@@ -1730,6 +1917,1369 @@ export class DeleteDataResp {
     }
 }
 
+/**
+ * 酒水标签
+ */
+export class DrinkTag {
+    /**
+     * @param category: Category  酒类分类
+     * @param name: string  酒类名称
+     * @param amount: number  酒类数量
+     */
+    constructor(category,name,amount,) {
+        this.category = category;
+        this.name = name;
+        this.amount = amount;
+        
+    }
+    static fromObject(o) {
+        return new DrinkTag(o.category,o.name,o.amount,);
+    }
+}
+
+/**
+ * 获取酒友圈动态请求
+ */
+export class GetFeedsReq {
+    /**
+     * @param lastId: string|number  最后一条动态ID，用于分页
+     * @param pageSize: number  每页数量
+     */
+    constructor(lastId,pageSize,) {
+        this.lastId = lastId;
+        this.pageSize = pageSize;
+        
+    }
+    static fromObject(o) {
+        return new GetFeedsReq(o.lastId,o.pageSize,);
+    }
+}
+
+/**
+ * 动态信息
+ */
+export class Feed {
+    /**
+     * @param id: string|number  动态ID
+     * @param userId: string|number  用户ID
+     * @param nickname: string  昵称
+     * @param avatar: string  头像
+     * @param time: string  发布时间
+     * @param text: string  动态文本
+     * @param drinks: Array<DrinkTag>  酒水标签
+     * @param feeling: Feeling  自我感觉
+     * @param images: Array<string>  图片列表
+     * @param likes: number  点赞数
+     * @param liked: boolean  是否点赞
+     * @param comments: number  评论数
+     */
+    constructor(id,userId,nickname,avatar,time,text,drinks,feeling,images,likes,liked,comments,) {
+        this.id = id;
+        this.userId = userId;
+        this.nickname = nickname;
+        this.avatar = avatar;
+        this.time = time;
+        this.text = text;
+        this.drinks = drinks;
+        this.feeling = feeling;
+        this.images = images;
+        this.likes = likes;
+        this.liked = liked;
+        this.comments = comments;
+        
+    }
+    static fromObject(o) {
+        return new Feed(o.id,o.userId,o.nickname,o.avatar,o.time,o.text,o.drinks,o.feeling,o.images,o.likes,o.liked,o.comments,);
+    }
+}
+
+/**
+ * 动态列表响应
+ */
+export class GetFeedsResp {
+    /**
+     * @param list: Array<Feed>  动态列表
+     * @param hasMore: boolean  是否还有更多动态
+     */
+    constructor(list,hasMore,) {
+        this.list = list;
+        this.hasMore = hasMore;
+        
+    }
+    static fromObject(o) {
+        return new GetFeedsResp(o.list,o.hasMore,);
+    }
+}
+
+/**
+ * 发布动态请求
+ */
+export class PublishFeedReq {
+    /**
+     * @param text: string  动态文本
+     * @param images: Array<string>  图片列表
+     * @param recordId: string|number  关联的记录ID
+     * @param visibility: Visibility  可见性
+     */
+    constructor(text,images,recordId,visibility,) {
+        this.text = text;
+        this.images = images;
+        this.recordId = recordId;
+        this.visibility = visibility;
+        
+    }
+    static fromObject(o) {
+        return new PublishFeedReq(o.text,o.images,o.recordId,o.visibility,);
+    }
+}
+
+/**
+ * 发布动态响应
+ */
+export class PublishFeedResp {
+    /**
+     * @param success: boolean  是否成功
+     * @param feedId: string|number  动态ID
+     */
+    constructor(success,feedId,) {
+        this.success = success;
+        this.feedId = feedId;
+        
+    }
+    static fromObject(o) {
+        return new PublishFeedResp(o.success,o.feedId,);
+    }
+}
+
+/**
+ * 点赞/取消点赞请求（路径参数）
+ */
+export class LikeFeedReq {
+    /**
+     * @param id: string|number  动态ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new LikeFeedReq(o.id,);
+    }
+}
+
+/**
+ * 点赞响应
+ */
+export class LikeFeedResp {
+    /**
+     * @param ok: boolean  是否成功
+     */
+    constructor(ok,) {
+        this.ok = ok;
+        
+    }
+    static fromObject(o) {
+        return new LikeFeedResp(o.ok,);
+    }
+}
+
+/**
+ * 
+ */
+export class UnlikeFeedReq {
+    /**
+     * @param id: string|number  动态ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new UnlikeFeedReq(o.id,);
+    }
+}
+
+/**
+ * 取消点赞响应
+ */
+export class UnlikeFeedResp {
+    /**
+     * @param ok: boolean  是否成功
+     */
+    constructor(ok,) {
+        this.ok = ok;
+        
+    }
+    static fromObject(o) {
+        return new UnlikeFeedResp(o.ok,);
+    }
+}
+
+/**
+ * 评论信息
+ */
+export class Comment {
+    /**
+     * @param id: string|number  评论ID
+     * @param userId: string|number  用户ID
+     * @param nickname: string  昵称
+     * @param avatar: string  头像
+     * @param content: string  评论内容
+     * @param time: string  评论时间
+     */
+    constructor(id,userId,nickname,avatar,content,time,) {
+        this.id = id;
+        this.userId = userId;
+        this.nickname = nickname;
+        this.avatar = avatar;
+        this.content = content;
+        this.time = time;
+        
+    }
+    static fromObject(o) {
+        return new Comment(o.id,o.userId,o.nickname,o.avatar,o.content,o.time,);
+    }
+}
+
+/**
+ * 评论列表响应
+ */
+export class CommentListData {
+    /**
+     * @param list: Array<Comment>  评论列表
+     */
+    constructor(list,) {
+        this.list = list;
+        
+    }
+    static fromObject(o) {
+        return new CommentListData(o.list,);
+    }
+}
+
+/**
+ * 获取评论请求（路径参数）
+ */
+export class GetFeedCommentsReq {
+    /**
+     * @param id: string|number  动态ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new GetFeedCommentsReq(o.id,);
+    }
+}
+
+/**
+ * 发表评论请求（含路径参数）
+ */
+export class AddCommentFullReq {
+    /**
+     * @param id: string|number  动态ID
+     * @param content: string  评论内容
+     */
+    constructor(id,content,) {
+        this.id = id;
+        this.content = content;
+        
+    }
+    static fromObject(o) {
+        return new AddCommentFullReq(o.id,o.content,);
+    }
+}
+
+/**
+ * 发表评论响应
+ */
+export class AddCommentResp {
+    /**
+     * @param id: string|number  评论ID
+     * @param userId: string|number  用户ID
+     * @param nickname: string  昵称
+     * @param avatar: string  头像
+     * @param content: string  评论内容
+     * @param time: string  评论时间
+     */
+    constructor(id,userId,nickname,avatar,content,time,) {
+        this.id = id;
+        this.userId = userId;
+        this.nickname = nickname;
+        this.avatar = avatar;
+        this.content = content;
+        this.time = time;
+        
+    }
+    static fromObject(o) {
+        return new AddCommentResp(o.id,o.userId,o.nickname,o.avatar,o.content,o.time,);
+    }
+}
+
+/**
+ * 酒友信息
+ */
+export class Friend {
+    /**
+     * @param id: string|number  酒友ID
+     * @param nickname: string  昵称
+     * @param avatar: string  头像
+     * @param lastDrink: string|number  最近一次喝的酒
+     * @param lastDrinkTime: string  最近一次喝的酒时间
+     * @param online: boolean  是否在线
+     */
+    constructor(id,nickname,avatar,lastDrink,lastDrinkTime,online,) {
+        this.id = id;
+        this.nickname = nickname;
+        this.avatar = avatar;
+        this.lastDrink = lastDrink;
+        this.lastDrinkTime = lastDrinkTime;
+        this.online = online;
+        
+    }
+    static fromObject(o) {
+        return new Friend(o.id,o.nickname,o.avatar,o.lastDrink,o.lastDrinkTime,o.online,);
+    }
+}
+
+/**
+ * 获取好友请求列表请求
+ */
+export class GetFriendRequestsReq {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new GetFriendRequestsReq();
+    }
+}
+
+/**
+ * 酒友列表响应
+ */
+export class GetFriendRequestsResp {
+    /**
+     * @param list: Array<Friend>  分页数据
+     */
+    constructor(list,) {
+        this.list = list;
+        
+    }
+    static fromObject(o) {
+        return new GetFriendRequestsResp(o.list,);
+    }
+}
+
+/**
+ * 获取酒友列表请求
+ */
+export class GetFriendsReq {
+    /**
+     * @param keyword: string  搜索关键词
+     */
+    constructor(keyword,) {
+        this.keyword = keyword;
+        
+    }
+    static fromObject(o) {
+        return new GetFriendsReq(o.keyword,);
+    }
+}
+
+/**
+ * 好友请求信息
+ */
+export class FriendRequest {
+    /**
+     * @param id: string|number  好友请求ID
+     * @param userId: string|number  酒友ID
+     * @param nickname: string  昵称
+     * @param avatar: string  头像
+     * @param message: string  消息
+     * @param time: string  创建时间
+     */
+    constructor(id,userId,nickname,avatar,message,time,) {
+        this.id = id;
+        this.userId = userId;
+        this.nickname = nickname;
+        this.avatar = avatar;
+        this.message = message;
+        this.time = time;
+        
+    }
+    static fromObject(o) {
+        return new FriendRequest(o.id,o.userId,o.nickname,o.avatar,o.message,o.time,);
+    }
+}
+
+/**
+ * 好友请求列表响应
+ */
+export class FriendRequestListData {
+    /**
+     * @param list: Array<FriendRequest>  分页数据
+     */
+    constructor(list,) {
+        this.list = list;
+        
+    }
+    static fromObject(o) {
+        return new FriendRequestListData(o.list,);
+    }
+}
+
+/**
+ * 发送好友请求
+ */
+export class SendFriendRequestReq {
+    /**
+     * @param userId: string|number  酒友ID
+     * @param message: string  消息
+     */
+    constructor(userId,message,) {
+        this.userId = userId;
+        this.message = message;
+        
+    }
+    static fromObject(o) {
+        return new SendFriendRequestReq(o.userId,o.message,);
+    }
+}
+
+/**
+ * 发送好友请求响应
+ */
+export class SendFriendRequestResp {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new SendFriendRequestResp();
+    }
+}
+
+/**
+ * 接受好友请求（路径参数）
+ */
+export class AcceptFriendRequestReq {
+    /**
+     * @param id: string|number  好友请求ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new AcceptFriendRequestReq(o.id,);
+    }
+}
+
+/**
+ * 接受好友请求响应
+ */
+export class AcceptFriendRequestResp {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new AcceptFriendRequestResp();
+    }
+}
+
+/**
+ * 删除酒友请求（路径参数）
+ */
+export class RemoveFriendReq {
+    /**
+     * @param userId: string|number  酒友ID
+     */
+    constructor(userId,) {
+        this.userId = userId;
+        
+    }
+    static fromObject(o) {
+        return new RemoveFriendReq(o.userId,);
+    }
+}
+
+/**
+ * 删除酒友响应
+ */
+export class RemoveFriendResp {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new RemoveFriendResp();
+    }
+}
+
+/**
+ * 酒局信息
+ */
+export class Event {
+    /**
+     * @param id: string|number  酒局ID
+     * @param title: string  酒局标题
+     * @param organizer: User  酒局组织者
+     * @param time: string  酒局时间
+     * @param location: string  酒局地点
+     * @param maxPeople: number  最大人数
+     * @param joined: number  已报名人数
+     * @param participants: Array<User>  已报名用户
+     * @param status: EventStatus  酒局状态
+     * @param note: string  酒局备注
+     * @param isJoined: boolean  是否已报名
+     * @param isOrganizer: boolean  是否为组织者
+     */
+    constructor(id,title,organizer,time,location,maxPeople,joined,participants,status,note,isJoined,isOrganizer,) {
+        this.id = id;
+        this.title = title;
+        this.organizer = organizer;
+        this.time = time;
+        this.location = location;
+        this.maxPeople = maxPeople;
+        this.joined = joined;
+        this.participants = participants;
+        this.status = status;
+        this.note = note;
+        this.isJoined = isJoined;
+        this.isOrganizer = isOrganizer;
+        
+    }
+    static fromObject(o) {
+        return new Event(o.id,o.title,o.organizer,o.time,o.location,o.maxPeople,o.joined,o.participants,o.status,o.note,o.isJoined,o.isOrganizer,);
+    }
+}
+
+/**
+ * 酒局列表响应
+ */
+export class EventListData {
+    /**
+     * @param list: Array<Event>  分页数据
+     */
+    constructor(list,) {
+        this.list = list;
+        
+    }
+    static fromObject(o) {
+        return new EventListData(o.list,);
+    }
+}
+
+/**
+ * 获取酒局列表请求
+ */
+export class GetEventsReq {
+    /**
+     * @param status: EventStatus  状态筛选
+     */
+    constructor(status,) {
+        this.status = status;
+        
+    }
+    static fromObject(o) {
+        return new GetEventsReq(o.status,);
+    }
+}
+
+/**
+ * 获取酒局详情请求（路径参数）
+ */
+export class GetEventDetailReq {
+    /**
+     * @param id: string|number  酒局ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new GetEventDetailReq(o.id,);
+    }
+}
+
+/**
+ * 坐标信息
+ */
+export class GeoPoint {
+    /**
+     * @param latitude: number  纬度
+     * @param longitude: number  经度
+     */
+    constructor(latitude,longitude,) {
+        this.latitude = latitude;
+        this.longitude = longitude;
+        
+    }
+    static fromObject(o) {
+        return new GeoPoint(o.latitude,o.longitude,);
+    }
+}
+
+/**
+ * 发起酒局请求
+ */
+export class CreateEventReq {
+    /**
+     * @param title: string  酒局标题
+     * @param time: string  酒局时间
+     * @param location: string  酒局地点
+     * @param maxPeople: number  最大人数
+     * @param geo: GeoPoint  坐标信息
+     * @param note: string  酒局备注
+     */
+    constructor(title,time,location,maxPeople,geo,note,) {
+        this.title = title;
+        this.time = time;
+        this.location = location;
+        this.maxPeople = maxPeople;
+        this.geo = geo;
+        this.note = note;
+        
+    }
+    static fromObject(o) {
+        return new CreateEventReq(o.title,o.time,o.location,o.maxPeople,o.geo,o.note,);
+    }
+}
+
+/**
+ * 发起酒局响应
+ */
+export class CreateEventResp {
+    /**
+     * @param eventId: string|number  酒局ID
+     */
+    constructor(eventId,) {
+        this.eventId = eventId;
+        
+    }
+    static fromObject(o) {
+        return new CreateEventResp(o.eventId,);
+    }
+}
+
+/**
+ * 报名/取消/签到请求（路径参数）
+ */
+export class JoinEventReq {
+    /**
+     * @param id: string|number  酒局ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new JoinEventReq(o.id,);
+    }
+}
+
+/**
+ * 
+ */
+export class JoinEventResp {
+    /**
+     * @param ok: boolean  是否成功
+     */
+    constructor(ok,) {
+        this.ok = ok;
+        
+    }
+    static fromObject(o) {
+        return new JoinEventResp(o.ok,);
+    }
+}
+
+/**
+ * 
+ */
+export class QuitEventReq {
+    /**
+     * @param id: string|number  酒局ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new QuitEventReq(o.id,);
+    }
+}
+
+/**
+ * 
+ */
+export class QuitEventResp {
+    /**
+     * @param ok: boolean  是否成功
+     */
+    constructor(ok,) {
+        this.ok = ok;
+        
+    }
+    static fromObject(o) {
+        return new QuitEventResp(o.ok,);
+    }
+}
+
+/**
+ * 
+ */
+export class CheckInEventReq {
+    /**
+     * @param id: string|number  酒局ID
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new CheckInEventReq(o.id,);
+    }
+}
+
+/**
+ * 
+ */
+export class CheckInEventResp {
+    /**
+     * @param ok: boolean  是否成功
+     */
+    constructor(ok,) {
+        this.ok = ok;
+        
+    }
+    static fromObject(o) {
+        return new CheckInEventResp(o.ok,);
+    }
+}
+
+/**
+ * 会话信息
+ */
+export class Conversation {
+    /**
+     * @param id: string  会话ID
+     * @param friendId: string|number  对方用户ID
+     * @param nickname: string  对方昵称
+     * @param avatar: string  对方头像URL（可为空）
+     * @param lastMessage: string  最后一条消息摘要
+     * @param lastTime: string  最后消息时间（ISO 8601）
+     * @param unread: number  未读消息数
+     * @param online: boolean  对方是否在线
+     */
+    constructor(id,friendId,nickname,avatar,lastMessage,lastTime,unread,online,) {
+        this.id = id;
+        this.friendId = friendId;
+        this.nickname = nickname;
+        this.avatar = avatar;
+        this.lastMessage = lastMessage;
+        this.lastTime = lastTime;
+        this.unread = unread;
+        this.online = online;
+        
+    }
+    static fromObject(o) {
+        return new Conversation(o.id,o.friendId,o.nickname,o.avatar,o.lastMessage,o.lastTime,o.unread,o.online,);
+    }
+}
+
+/**
+ * 
+ */
+export class GetConversationsReq {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new GetConversationsReq();
+    }
+}
+
+/**
+ * 获取会话列表响应
+ */
+export class GetConversationsResp {
+    /**
+     * @param list: Array<Conversation>  会话列表
+     */
+    constructor(list,) {
+        this.list = list;
+        
+    }
+    static fromObject(o) {
+        return new GetConversationsResp(o.list,);
+    }
+}
+
+/**
+ * 获取历史消息请求
+ */
+export class GetMessagesReq {
+    /**
+     * @param conversationId: string  会话ID
+     * @param lastID: string|number  游标分页
+     * @param pageSize: number  每页数量，默认20
+     */
+    constructor(conversationId,lastID,pageSize,) {
+        this.conversationId = conversationId;
+        this.lastID = lastID;
+        this.pageSize = pageSize;
+        
+    }
+    static fromObject(o) {
+        return new GetMessagesReq(o.conversationId,o.lastID,o.pageSize,);
+    }
+}
+
+/**
+ * 消息记录
+ */
+export class Message {
+    /**
+     * @param id: string|number  消息ID
+     * @param conversationId: string  会话ID
+     * @param senderId: string|number  发送者ID
+     * @param receiverId: string|number  接收者ID
+     * @param type: MessageType  消息类型
+     * @param content: string  消息内容
+     * @param timestamp: number  发送时间（毫秒时间戳）
+     * @param status: MessageStatus  消息状态
+     */
+    constructor(id,conversationId,senderId,receiverId,type,content,timestamp,status,) {
+        this.id = id;
+        this.conversationId = conversationId;
+        this.senderId = senderId;
+        this.receiverId = receiverId;
+        this.type = type;
+        this.content = content;
+        this.timestamp = timestamp;
+        this.status = status;
+        
+    }
+    static fromObject(o) {
+        return new Message(o.id,o.conversationId,o.senderId,o.receiverId,o.type,o.content,o.timestamp,o.status,);
+    }
+}
+
+/**
+ * 获取历史消息响应
+ */
+export class GetMessagesResp {
+    /**
+     * @param list: Array<Message>  消息列表
+     * @param hasMore: boolean  是否还有更多消息
+     */
+    constructor(list,hasMore,) {
+        this.list = list;
+        this.hasMore = hasMore;
+        
+    }
+    static fromObject(o) {
+        return new GetMessagesResp(o.list,o.hasMore,);
+    }
+}
+
+/**
+ * 标记已读请求（路径参数）
+ */
+export class MarkReadReq {
+    /**
+     * @param id: string  会话ID（路径参数）
+     */
+    constructor(id,) {
+        this.id = id;
+        
+    }
+    static fromObject(o) {
+        return new MarkReadReq(o.id,);
+    }
+}
+
+/**
+ * 标记已读响应
+ */
+export class MarkReadResp {
+    /**
+     * @param success: boolean  是否成功
+     */
+    constructor(success,) {
+        this.success = success;
+        
+    }
+    static fromObject(o) {
+        return new MarkReadResp(o.success,);
+    }
+}
+
+/**
+ * 
+ */
+export class GetUnreadCountReq {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new GetUnreadCountReq();
+    }
+}
+
+/**
+ * 获取未读总数响应
+ */
+export class GetUnreadCountResp {
+    /**
+     * @param total: number  未读总数
+     */
+    constructor(total,) {
+        this.total = total;
+        
+    }
+    static fromObject(o) {
+        return new GetUnreadCountResp(o.total,);
+    }
+}
+
+/**
+ * 客户端 - 发送聊天数据
+ */
+export class ClientChatData {
+    /**
+     * @param receiverId: string|number  接收者ID
+     * @param content: string  消息内容
+     * @param msgType: MessageType  消息类型
+     * @param clientMesgId: string|number  客户端消息ID
+     */
+    constructor(receiverId,content,msgType,clientMesgId,) {
+        this.receiverId = receiverId;
+        this.content = content;
+        this.msgType = msgType;
+        this.clientMesgId = clientMesgId;
+        
+    }
+    static fromObject(o) {
+        return new ClientChatData(o.receiverId,o.content,o.msgType,o.clientMesgId,);
+    }
+}
+
+/**
+ * 客户端 - 输入状态数据
+ */
+export class ClientTypingData {
+    /**
+     * @param receiverId: string|number  接收者ID
+     */
+    constructor(receiverId,) {
+        this.receiverId = receiverId;
+        
+    }
+    static fromObject(o) {
+        return new ClientTypingData(o.receiverId,);
+    }
+}
+
+/**
+ * 客户端 - 已读回执数据
+ */
+export class ClientReadData {
+    /**
+     * @param conversationId: string  会话ID
+     * @param lastMsgId: string|number  最后一条消息ID
+     */
+    constructor(conversationId,lastMsgId,) {
+        this.conversationId = conversationId;
+        this.lastMsgId = lastMsgId;
+        
+    }
+    static fromObject(o) {
+        return new ClientReadData(o.conversationId,o.lastMsgId,);
+    }
+}
+
+/**
+ * 客户端 - ping 数据（空）
+ */
+export class ClientPingData {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new ClientPingData();
+    }
+}
+
+/**
+ * 服务端 - 推送聊天数据
+ */
+export class ServerChatData {
+    /**
+     * @param msgId: string|number  消息ID
+     * @param senderId: string|number  发送者ID
+     * @param receiverId: string|number  接收者ID
+     * @param conversationId: string  会话ID
+     * @param content: string  消息内容
+     * @param msgType: MessageType  消息类型
+     * @param timestamp: number  发送时间（毫秒时间戳）
+     */
+    constructor(msgId,senderId,receiverId,conversationId,content,msgType,timestamp,) {
+        this.msgId = msgId;
+        this.senderId = senderId;
+        this.receiverId = receiverId;
+        this.conversationId = conversationId;
+        this.content = content;
+        this.msgType = msgType;
+        this.timestamp = timestamp;
+        
+    }
+    static fromObject(o) {
+        return new ServerChatData(o.msgId,o.senderId,o.receiverId,o.conversationId,o.content,o.msgType,o.timestamp,);
+    }
+}
+
+/**
+ * 服务端 - 推送输入状态数据
+ */
+export class ServerTypingData {
+    /**
+     * @param senderId: string|number  发送者ID
+     */
+    constructor(senderId,) {
+        this.senderId = senderId;
+        
+    }
+    static fromObject(o) {
+        return new ServerTypingData(o.senderId,);
+    }
+}
+
+/**
+ * 服务端 - 推送已读回执数据
+ */
+export class ServerReadData {
+    /**
+     * @param conversationId: string  会话ID
+     * @param readerId: string|number  读取者ID
+     */
+    constructor(conversationId,readerId,) {
+        this.conversationId = conversationId;
+        this.readerId = readerId;
+        
+    }
+    static fromObject(o) {
+        return new ServerReadData(o.conversationId,o.readerId,);
+    }
+}
+
+/**
+ * 服务端 - ACK 数据
+ */
+export class ServerAckData {
+    /**
+     * @param clientMsgId: string|number  客户端消息ID
+     * @param msgId: string|number  消息ID
+     * @param status: MessageStatus  消息状态
+     */
+    constructor(clientMsgId,msgId,status,) {
+        this.clientMsgId = clientMsgId;
+        this.msgId = msgId;
+        this.status = status;
+        
+    }
+    static fromObject(o) {
+        return new ServerAckData(o.clientMsgId,o.msgId,o.status,);
+    }
+}
+
+/**
+ * 服务端 - pong 数据（空）
+ */
+export class ServerPongData {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new ServerPongData();
+    }
+}
+
+/**
+ * 服务端 - 连接成功数据
+ */
+export class ServerConnectedData {
+    /**
+     * @param userId: string|number  用户ID
+     */
+    constructor(userId,) {
+        this.userId = userId;
+        
+    }
+    static fromObject(o) {
+        return new ServerConnectedData(o.userId,);
+    }
+}
+
+/**
+ * 服务端 - 被踢下线数据（空）
+ */
+export class ServerKickedData {
+    /**
+     */
+    constructor() {
+        
+    }
+    static fromObject(o) {
+        return new ServerKickedData();
+    }
+}
+
+/**
+ * 
+ */
+export class ChatWebSocket {
+    /**
+     * @param mesgType: ClientMesgType  消息类型
+     * @param data: ClientMessage  消息数据
+     */
+    constructor(mesgType,data,) {
+        this.mesgType = mesgType;
+        this.data = data;
+        
+    }
+    static fromObject(o) {
+        return new ChatWebSocket(o.mesgType,o.data,);
+    }
+}
+
+/**
+ * WebSocket 响应
+ */
+export class ChatWebSocketResp {
+    /**
+     * @param mesgType: ServerMesgType  消息类型
+     * @param data: ServerMessage  消息数据
+     */
+    constructor(mesgType,data,) {
+        this.mesgType = mesgType;
+        this.data = data;
+        
+    }
+    static fromObject(o) {
+        return new ChatWebSocketResp(o.mesgType,o.data,);
+    }
+}
+
+export class ChatWebSocketConn {
+    /**
+     * 构造函数
+     *
+     * @param host string 主机名
+     */
+    constructor(host) {
+        this.host = host;
+        this.reconnect = true;
+        this.reconnectDelay = 1000;
+        this.maxReconnectDelay = 5000;
+        this.randomizationFactor = 0.5;
+        this.attempt = 0;
+        this.connect();
+    }
+    backoff(attempt) {
+        let delay = this.reconnectDelay * Math.pow(2, attempt);
+        if (delay > this.maxReconnectDelay) {
+          delay = this.maxReconnectDelay;
+        }
+        const jitter = this.randomizationFactor * (2 * Math.random() - 1);
+        let delayWithJitter = delay * (1 + jitter);
+        if (delayWithJitter < 0) {
+          delayWithJitter = 0;
+        }
+        return delayWithJitter;
+    }
+    connect() {
+        let socket = new WebSocket(`ws://${this.host}/api/have_a_drink/v1/chat/chat`);
+        socket.onopen = (event) => {
+            this.onopen(event);
+        };
+        socket.onerror = (err) => {
+            this.onerror(err);
+        };
+        socket.onclose = (event) => {
+            this.onclose(event);
+            if (this.reconnect) {
+                setTimeout(() => {
+                    this.connect();
+                }, this.backoff(this.attempt++));
+            }
+        };
+        socket.onmessage = (event) => {
+            this.onmessage(event);
+            
+            const data = JSON.parse(event.data);
+            switch (data.mesgType) { 
+            case ServerMesgType.Chat:
+                if (this.onServerChatData) {
+                    this.onServerChatData(data.data);
+                }
+                break;
+            case ServerMesgType.Typing:
+                if (this.onServerTypingData) {
+                    this.onServerTypingData(data.data);
+                }
+                break;
+            case ServerMesgType.Read:
+                if (this.onServerReadData) {
+                    this.onServerReadData(data.data);
+                }
+                break;
+            case ServerMesgType.Ack:
+                if (this.onServerAckData) {
+                    this.onServerAckData(data.data);
+                }
+                break;
+            case ServerMesgType.Pong:
+                if (this.onServerPongData) {
+                    this.onServerPongData(data.data);
+                }
+                break;
+            case ServerMesgType.Connected:
+                if (this.onServerConnectedData) {
+                    this.onServerConnectedData(data.data);
+                }
+                break;
+            case ServerMesgType.Kicked:
+                if (this.onServerKickedData) {
+                    this.onServerKickedData(data.data);
+                }
+                break;
+            }
+        };
+        this.socket = socket;
+    }
+    /**
+     * 当连接打开时调用
+     *
+     * @param {Event} event - 打开事件
+     */
+    onopen(event) {}
+    /**
+     * 当收到消息时调用
+     *
+     * @param {MessageEvent} event - 消息事件
+     */
+    onmessage(event) {}
+    /**
+     * 当收到 ServerChatData 消息时调用
+     *
+     * @param {ServerChatData} data - 消息数据
+     */
+    onServerChatData(data) {}
+    
+    /**
+     * 当收到 ServerTypingData 消息时调用
+     *
+     * @param {ServerTypingData} data - 消息数据
+     */
+    onServerTypingData(data) {}
+    
+    /**
+     * 当收到 ServerReadData 消息时调用
+     *
+     * @param {ServerReadData} data - 消息数据
+     */
+    onServerReadData(data) {}
+    
+    /**
+     * 当收到 ServerAckData 消息时调用
+     *
+     * @param {ServerAckData} data - 消息数据
+     */
+    onServerAckData(data) {}
+    
+    /**
+     * 当收到 ServerPongData 消息时调用
+     *
+     * @param {ServerPongData} data - 消息数据
+     */
+    onServerPongData(data) {}
+    
+    /**
+     * 当收到 ServerConnectedData 消息时调用
+     *
+     * @param {ServerConnectedData} data - 消息数据
+     */
+    onServerConnectedData(data) {}
+    
+    /**
+     * 当收到 ServerKickedData 消息时调用
+     *
+     * @param {ServerKickedData} data - 消息数据
+     */
+    onServerKickedData(data) {}
+    
+    
+    writeClientChatData(data) {
+        this.socket.send(JSON.stringify({
+            mesgType: ClientMesgType.Chat,
+            data: data,
+        }));
+    }
+    writeClientTypingData(data) {
+        this.socket.send(JSON.stringify({
+            mesgType: ClientMesgType.Typing,
+            data: data,
+        }));
+    }
+    writeClientReadData(data) {
+        this.socket.send(JSON.stringify({
+            mesgType: ClientMesgType.Read,
+            data: data,
+        }));
+    }
+    writeClientPingData(data) {
+        this.socket.send(JSON.stringify({
+            mesgType: ClientMesgType.Ping,
+            data: data,
+        }));
+    }
+    /**
+     * 当连接关闭时调用
+     *
+     * @param {CloseEvent} event - 关闭事件
+     */
+    onclose(event) {}
+    /**
+     * 当发生错误时调用
+     *
+     * @param {ErrorEvent} event - 错误事件
+     */
+    onerror(event) {}
+    /**
+     * 关闭连接
+     */
+    close() {
+        this.reconnect = false;
+        this.socket.close();
+    }
+}
 
 /**
  * * 喝酒了么 - 后端接口 API
@@ -1919,70 +3469,6 @@ export default class HaveADrink {
         });
     }
     
-    /**
-    * 点赞
-    */
-    LikeRecord(req) {
-        return new Promise((reslove, reject)=>{
-            let data = req;
-            let url = `${this.host}/api/have_a_drink/v1/communication/records/like`;
-            
-            
-            this.http_request(url, {
-                uri: '/api/have_a_drink/v1/communication/records/like',
-                method: 'POST',
-                data: data,
-                responseType: 'json',
-                headers: { 
-                    'Content-Type': 'application/json',
-                },
-            }).then((data)=>{
-                if (data.hasOwnProperty("fail")) {
-                    if (data.fail) {
-                        reject(data.msg);
-                    } else {
-                        reslove(data.data);
-                    }
-                } else {
-                    reslove(data);
-                }
-            }).catch((err)=>reject(err));
-            
-        });
-    }
-    
-    /**
-    * 取消点赞
-    */
-    UnlikeRecord(req) {
-        return new Promise((reslove, reject)=>{
-            let data = req;
-            let url = `${this.host}/api/have_a_drink/v1/communication/records/unlike`;
-            
-            
-            this.http_request(url, {
-                uri: '/api/have_a_drink/v1/communication/records/unlike',
-                method: 'POST',
-                data: data,
-                responseType: 'json',
-                headers: { 
-                    'Content-Type': 'application/json',
-                },
-            }).then((data)=>{
-                if (data.hasOwnProperty("fail")) {
-                    if (data.fail) {
-                        reject(data.msg);
-                    } else {
-                        reslove(data.data);
-                    }
-                } else {
-                    reslove(data);
-                }
-            }).catch((err)=>reject(err));
-            
-        });
-    }
-    
     /**
     * 上传照片
     */
@@ -2395,4 +3881,684 @@ export default class HaveADrink {
         });
     }
     
+    /**
+    * 动态信息流
+    */
+    GetFeeds(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/moments/feeds`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/moments/feeds',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 发布动态
+    */
+    PublishFeed(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/moments/feeds`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/moments/feeds',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 点赞
+    */
+    LikeFeed(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/moments/feeds/like`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/moments/feeds/like',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 取消点赞
+    */
+    UnlikeFeed(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/moments/feeds/unlike`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/moments/feeds/unlike',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 获取评论
+    */
+    GetFeedComments(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/moments/feeds/comments`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/moments/feeds/comments',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 发表评论
+    */
+    AddComment(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/moments/feeds/comments`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/moments/feeds/comments',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 酒友管理
+    */
+    GetFriends(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/friends/friends`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/friends/friends',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 好友请求管理
+    */
+    GetFriendRequests(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/friends/friend-requests`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/friends/friend-requests',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 发送好友请求
+    */
+    SendFriendRequest(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/friends/friend-requests`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/friends/friend-requests',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 接受好友请求
+    */
+    AcceptFriendRequest(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/friends/friend-requests/accept`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/friends/friend-requests/accept',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 删除酒友
+    */
+    RemoveFriend(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/friends/friends`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/friends/friends',
+                method: 'DELETE',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 约酒活动
+    */
+    GetEvents(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/events/events`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/events/events',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 获取酒局详情
+    */
+    GetEventDetail(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/events/events/detail`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/events/events/detail',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 发起酒局
+    */
+    CreateEvent(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/events/events`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/events/events',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 报名酒局
+    */
+    JoinEvent(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/events/events/join`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/events/events/join',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 取消报名酒局
+    */
+    QuitEvent(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/events/events/quit`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/events/events/quit',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 签到酒局
+    */
+    CheckInEvent(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/events/events/checkin`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/events/events/checkin',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 获取会话列表
+    */
+    GetConversations(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/chat/conversations`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/chat/conversations',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 获取历史消息
+    */
+    GetMessages(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/chat/messages`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/chat/messages',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 标记会话已读
+    */
+    MarkRead(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/chat/conversations/read`;
+            
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/chat/conversations/read',
+                method: 'POST',
+                data: data,
+                responseType: 'json',
+                headers: { 
+                    'Content-Type': 'application/json',
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 获取未读消息总数
+    */
+    GetUnreadCount(req) {
+        return new Promise((reslove, reject)=>{
+            let data = req;
+            let url = `${this.host}/api/have_a_drink/v1/chat/unread-count`;
+            const query = Object.keys(data).map((x)=>(`${x}=${data[x]}`)).join('&');
+            
+            this.http_request(url, {
+                uri: '/api/have_a_drink/v1/chat/unread-count',
+                method: 'GET',
+                query: query,
+                data: data,
+                responseType: 'json',
+                headers: { 
+                },
+            }).then((data)=>{
+                if (data.hasOwnProperty("fail")) {
+                    if (data.fail) {
+                        reject(data.msg);
+                    } else {
+                        reslove(data.data);
+                    }
+                } else {
+                    reslove(data);
+                }
+            }).catch((err)=>reject(err));
+            
+        });
+    }
+    
+    /**
+    * 注意：连接建立后，服务端会先验证 token，然后推送 connected 事件
+    */
+    ChatWebSocket() {
+        const url = new URL(this.host);
+        return new ChatWebSocketConn(url.host);
+    }
+
 }
diff --git a/node_modules/HaveADrink/package.json b/node_modules/HaveADrink/package.json
index a9ad47c..898a687 100644
--- a/node_modules/HaveADrink/package.json
+++ b/node_modules/HaveADrink/package.json
@@ -1,7 +1,7 @@
 {
   "name": "HaveADrink",
   "type": "module",
-  "version": "v1.0.4",
+  "version": "v1.0.8",
   "description": "喝酒了么 API 服务",
   "main": "index.js",
   "scripts": {
diff --git a/package-lock.json b/package-lock.json
index 6f3a24d..6bbaee1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -5,13 +5,13 @@
   "packages": {
     "": {
       "dependencies": {
-        "HaveADrink": "^1.0.4"
+        "HaveADrink": "^1.0.8"
       }
     },
     "node_modules/HaveADrink": {
-      "version": "1.0.4",
-      "resolved": "https://npm.wash-painting.cn/HaveADrink/-/HaveADrink-1.0.4.tgz",
-      "integrity": "sha512-kSSpTZrQGjRueftSAopurZcwXGMS3oKQ0mvP3/sePJh7odO5ev9FT31isXX0LLmL1HojzB4nrIeDb/PTdGhYuA==",
+      "version": "1.0.8",
+      "resolved": "https://npm.wash-painting.cn/HaveADrink/-/HaveADrink-1.0.8.tgz",
+      "integrity": "sha512-YOaqEZg+T1MKz1OtRJc09niyxEwm+52g91Yj0L2aGEy6bK6pTLJYlmREdneIStiniUGHVjL2/U5Qk57lTBAuFw==",
       "license": "ISC"
     }
   }
diff --git a/package.json b/package.json
index da8c42f..dfd69d8 100644
--- a/package.json
+++ b/package.json
@@ -1,5 +1,5 @@
 {
   "dependencies": {
-    "HaveADrink": "^1.0.4"
+    "HaveADrink": "^1.0.8"
   }
 }
diff --git a/pages/card/card.vue b/pages/card/card.vue
index 63eaf96..9502185 100644
--- a/pages/card/card.vue
+++ b/pages/card/card.vue
@@ -34,7 +34,6 @@
 <script>
 import DrinkCard from '../../components/DrinkCard.vue'
 import client from '../../common/api'
-import { getRecords } from '../../common/mock-data'
 import { calcStandardCups, unitToMl } from '../../common/utils'
 import { DRINK_CATEGORIES, FOOD_CATEGORIES, DRINK_QUOTES, FEELINGS } from '../../common/constants'
 import themeMixin from '../../common/theme-mixin'
@@ -86,7 +85,8 @@ export default {
     loadLocalRecord(id) {
       if (!id) return null
       try {
-        const records = getRecords()
+        let records = []
+        try { records = JSON.parse(uni.getStorageSync('drink_records') || '[]') } catch (e) { /* */ }
         const found = records.find(r => r.id === id)
         if (!found) return null
         return {
diff --git a/pages/chat-list/chat-list.vue b/pages/chat-list/chat-list.vue
index 0129dba..b977aa4 100644
--- a/pages/chat-list/chat-list.vue
+++ b/pages/chat-list/chat-list.vue
@@ -67,6 +67,7 @@
 <script>
 import EmptyState from '../../components/EmptyState.vue'
 import { GetConversations } from '../../common/api'
+import wsManager from '../../common/websocket'
 import themeMixin from '../../common/theme-mixin'
 
 export default {
@@ -83,6 +84,13 @@ export default {
   },
   onShow() {
     this.loadConversations()
+    this.bindWsEvents()
+  },
+  onHide() {
+    this.unbindWsEvents()
+  },
+  onUnload() {
+    this.unbindWsEvents()
   },
   methods: {
     async loadConversations() {
@@ -110,6 +118,31 @@ export default {
     },
     goCircle() {
       uni.switchTab({ url: '/pages/circle/circle' })
+    },
+
+    // === WebSocket 实时更新 ===
+    bindWsEvents() {
+      wsManager.on('message', this.onWsMessage)
+    },
+    unbindWsEvents() {
+      wsManager.off('message', this.onWsMessage)
+    },
+    /** 收到新消息时更新会话列表 */
+    onWsMessage(data) {
+      const convId = data.conversationId
+      const idx = this.conversations.findIndex(c => String(c.id) === String(convId))
+      if (idx >= 0) {
+        const conv = this.conversations[idx]
+        conv.lastMessage = data.content || '[新消息]'
+        conv.lastTime = '刚刚'
+        conv.unread = (conv.unread || 0) + 1
+        // 移动到顶部
+        this.conversations.splice(idx, 1)
+        this.conversations.unshift(conv)
+      } else {
+        // 新会话，重新加载列表
+        this.loadConversations()
+      }
     }
   }
 }
diff --git a/pages/chat/chat.vue b/pages/chat/chat.vue
index 0fae75f..b30c041 100644
--- a/pages/chat/chat.vue
+++ b/pages/chat/chat.vue
@@ -119,7 +119,7 @@
 </template>
 
 <script>
-import { GetMessages, MarkRead } from '../../common/api'
+import { GetMessages, MarkRead, GetConversations } from '../../common/api'
 import wsManager from '../../common/websocket'
 import themeMixin from '../../common/theme-mixin'
 
@@ -140,7 +140,7 @@ export default {
       isOnline: false,
       peerTyping: false,
       typingTimer: null,
-      page: 1,
+      lastID: 0,
       hasMore: true
     }
   },
@@ -148,9 +148,7 @@ export default {
     this.friendId = options.friendId || ''
     this.nickname = decodeURIComponent(options.nickname || '')
     this.conversationId = options.conversationId || ''
-    this.loadMessages()
-    this.markRead()
-    this.bindWsEvents()
+    this.initChat()
     // 监听键盘高度变化，动态调整输入栏位置（避免键盘顶起整个页面）
     uni.onKeyboardHeightChange(res => {
       this.keyboardHeight = res.height
@@ -176,12 +174,32 @@ export default {
     }
   },
   methods: {
+    // === 初始化聊天 ===
+    async initChat() {
+      // 如果没有传入 conversationId，通过会话列表查找
+      if (!this.conversationId && this.friendId) {
+        try {
+          const res = await GetConversations()
+          const conv = (res.data.list || []).find(c => String(c.friendId) === String(this.friendId))
+          if (conv) {
+            this.conversationId = conv.id
+          }
+        } catch (e) { /* ignore */ }
+      }
+      this.loadMessages()
+      this.markRead()
+      this.bindWsEvents()
+    },
     // === 数据加载 ===
     async loadMessages() {
       try {
-        const res = await GetMessages({ conversationId: this.conversationId, page: this.page })
-        this.messages = res.data.list
+        const res = await GetMessages({ conversationId: this.conversationId, lastID: this.lastID, pageSize: 20 })
+        this.messages = res.data.list || []
         this.hasMore = res.data.hasMore
+        // 记录最早一条消息ID作为加载更多游标
+        if (this.messages.length) {
+          this.lastID = this.messages[0].id
+        }
         this.$nextTick(() => {
           this.scrollToBottom()
         })
@@ -219,12 +237,12 @@ export default {
     /** 收到新消息 */
     onWsMessage(data) {
       // 只处理当前会话的消息
-      if (data.senderId !== this.friendId) return
+      if (String(data.senderId) !== String(this.friendId)) return
       const msg = {
-        id: data.msgId || 'msg_' + Date.now(),
-        conversationId: this.conversationId,
+        id: data.msgId ? String(data.msgId) : 'msg_' + Date.now(),
+        conversationId: data.conversationId || this.conversationId,
         senderId: data.senderId,
-        receiverId: 'user_001',
+        receiverId: data.receiverId,
         type: data.msgType || 'text',
         content: data.content,
         timestamp: data.timestamp || Date.now(),
@@ -242,7 +260,7 @@ export default {
 
     /** 对方正在输入 */
     onWsTyping(data) {
-      if (data.senderId !== this.friendId) return
+      if (String(data.senderId) !== String(this.friendId)) return
       this.peerTyping = true
       if (this.typingTimer) clearTimeout(this.typingTimer)
       this.typingTimer = setTimeout(() => {
@@ -252,9 +270,9 @@ export default {
 
     /** 消息送达确认 */
     onWsAck(data) {
-      const msg = this.messages.find(m => m.id === data.clientMsgId)
+      const msg = this.messages.find(m => m.id === data.clientMsgId || m.id === String(data.clientMsgId))
       if (msg) {
-        msg.id = data.msgId || msg.id
+        msg.id = data.msgId ? String(data.msgId) : msg.id
         msg.status = data.status || 'sent'
       }
     },
@@ -268,7 +286,7 @@ export default {
       const msg = {
         id: clientMsgId,
         conversationId: this.conversationId,
-        senderId: 'user_001',
+        senderId: wsManager.userId || 'self',
         receiverId: this.friendId,
         type: 'text',
         content: text,
@@ -288,13 +306,8 @@ export default {
         receiverId: this.friendId,
         content: text,
         msgType: 'text',
-        clientMsgId
+        clientMesgId: clientMsgId
       })
-
-      // 模拟确认（Mock模式下直接标记为已发送）
-      setTimeout(() => {
-        msg.status = 'sent'
-      }, 500)
     },
 
     /** 重发失败消息 */
@@ -303,12 +316,9 @@ export default {
       wsManager.send('chat', {
         receiverId: this.friendId,
         content: msg.content,
-        msgType: msg.type,
-        clientMsgId: msg.id
+        msgType: msg.type || 'text',
+        clientMesgId: msg.id
       })
-      setTimeout(() => {
-        msg.status = 'sent'
-      }, 500)
     },
 
     /** 点击发送按钮时记录时间戳 */
@@ -334,7 +344,7 @@ export default {
 
     // === 辅助方法 ===
     isSelf(msg) {
-      return msg.senderId === 'user_001'
+      return String(msg.senderId) === String(wsManager.userId) || msg.senderId === 'self'
     },
 
     showTimeDivider(idx) {
diff --git a/pages/circle-detail/circle-detail.vue b/pages/circle-detail/circle-detail.vue
index 1351647..14c7d43 100644
--- a/pages/circle-detail/circle-detail.vue
+++ b/pages/circle-detail/circle-detail.vue
@@ -62,8 +62,7 @@
 import FeedCard from '../../components/FeedCard.vue'
 import CommentItem from '../../components/CommentItem.vue'
 import EmptyState from '../../components/EmptyState.vue'
-import { GetCircleFeeds, GetFeedComments, AddComment, LikeFeed, UnlikeFeed } from '../../common/api'
-import { MOCK_FEEDS } from '../../common/mock-data'
+import { GetFeedComments, AddComment, LikeFeed, UnlikeFeed } from '../../common/api'
 import themeMixin from '../../common/theme-mixin'
 
 export default {
@@ -89,8 +88,10 @@ export default {
       uni.navigateBack()
     },
     async loadFeed() {
-      // 从 Mock 数据中查找对应动态
-      this.feed = MOCK_FEEDS.find(f => f.id === this.feedId) || MOCK_FEEDS[0]
+      // 从 globalData 中查找对应动态
+      const app = getApp()
+      const feeds = (app.globalData && app.globalData.circleFeeds) || []
+      this.feed = feeds.find(f => String(f.id) === String(this.feedId)) || null
     },
     async loadComments() {
       try {
diff --git a/pages/circle-publish/circle-publish.vue b/pages/circle-publish/circle-publish.vue
index 95ed100..0cce0c0 100644
--- a/pages/circle-publish/circle-publish.vue
+++ b/pages/circle-publish/circle-publish.vue
@@ -1,7 +1,7 @@
 <template>
   <view :class="themeClass" class="page-container publish-page">
     <!-- 顶部导航 -->
-    <view class="publish-nav" :style="{ paddingTop: navPaddingTop }">
+    <view class="publish-nav" :style="{ paddingTop: navPaddingTop, paddingRight: navPaddingRight }">
       <view class="publish-nav-inner">
         <view class="publish-back" @click="goBack">
           <text class="publish-back-icon">‹</text>
@@ -79,16 +79,18 @@
 </template>
 
 <script>
-import { PublishFeed } from '../../common/api'
-import { getRecords } from '../../common/mock-data'
+import { PublishFeed, UploadImage } from '../../common/api'
+import client from '../../common/api'
 import themeMixin from '../../common/theme-mixin'
 
 export default {
   mixins: [themeMixin],
   data() {
     const menuBtn = uni.getMenuButtonBoundingClientRect()
+    const sysInfo = uni.getSystemInfoSync()
     return {
       navPaddingTop: menuBtn.top + 'px',
+      navPaddingRight: (sysInfo.windowWidth - menuBtn.left + 8) + 'px',
       text: '',
       images: [],
       visibility: 'friends',
@@ -115,10 +117,11 @@ export default {
     goBack() {
       uni.navigateBack()
     },
-    loadLastRecord() {
+    async loadLastRecord() {
       try {
-        const records = getRecords()
-        const drank = records.find(r => r.mode === 'drank')
+        const res = await client.GetRecords({ page: 1, pageSize: 5, month: '', mode: '' })
+        const list = res.list || []
+        const drank = list.find(r => String(r.mode) === 'drank' || String(r.mode) === 'Drank')
         if (drank) this.lastRecord = drank
       } catch (e) { /* ignore */ }
     },
@@ -140,16 +143,29 @@ export default {
       if (!this.canSubmit) return
       this.publishing = true
       try {
+        // 先上传图片获取远程URL
+        let uploadedUrls = []
+        if (this.images.length) {
+          uni.showLoading({ title: '上传图片中...' })
+          for (const img of this.images) {
+            const upRes = await UploadImage({ filePath: img })
+            if (upRes.data && upRes.data.url) {
+              uploadedUrls.push(upRes.data.url)
+            }
+          }
+          uni.hideLoading()
+        }
         await PublishFeed({
           text: this.text,
-          images: this.images,
+          images: uploadedUrls,
           recordId: this.linkRecord && this.lastRecord ? this.lastRecord.id : null,
           visibility: this.visibility
         })
         uni.showToast({ title: '发布成功 🍻', icon: 'none' })
         setTimeout(() => uni.navigateBack(), 800)
       } catch (e) {
-        uni.showToast({ title: '发布失败', icon: 'none' })
+        uni.hideLoading()
+        // 全局拦截器已弹出错误提示
       }
       this.publishing = false
     }
diff --git a/pages/circle/circle.vue b/pages/circle/circle.vue
index f65040d..a14be59 100644
--- a/pages/circle/circle.vue
+++ b/pages/circle/circle.vue
@@ -121,6 +121,7 @@ import FriendItem from '../../components/FriendItem.vue'
 import EventCard from '../../components/EventCard.vue'
 import EmptyState from '../../components/EmptyState.vue'
 import { GetCircleFeeds, LikeFeed, UnlikeFeed, GetFriends, GetFriendRequests, GetEvents, GetUnreadCount } from '../../common/api'
+import wsManager from '../../common/websocket'
 import themeMixin from '../../common/theme-mixin'
 
 export default {
@@ -136,7 +137,7 @@ export default {
       headerPaddingRight: (sysInfo.windowWidth - menuBtn.left + 8) + 'px',
       // 动态
       feeds: [],
-      page: 1,
+      lastId: 0,
       hasMore: true,
       loading: false,
       refreshing: false,
@@ -154,6 +155,14 @@ export default {
     this.loadFriends()
     this.loadEvents()
     this.loadUnread()
+    this._wsHandler = () => { this.unreadTotal++ }
+    wsManager.on('message', this._wsHandler)
+  },
+  onHide() {
+    if (this._wsHandler) {
+      wsManager.off('message', this._wsHandler)
+      this._wsHandler = null
+    }
   },
   methods: {
     switchTab(i) {
@@ -163,20 +172,26 @@ export default {
     async loadFeeds(reset = false) {
       if (this.loading) return
       if (reset) {
-        this.page = 1
+        this.lastId = 0
         this.hasMore = true
       }
       this.loading = true
       try {
-        const res = await GetCircleFeeds({ page: this.page, pageSize: 10 })
+        const res = await GetCircleFeeds({ lastId: this.lastId, pageSize: 10 })
         const data = res.data
         if (reset) {
-          this.feeds = data.list
+          this.feeds = data.list || []
         } else {
-          this.feeds = [...this.feeds, ...data.list]
+          this.feeds = [...this.feeds, ...(data.list || [])]
         }
         this.hasMore = data.hasMore
-        this.page++
+        // 记录最后一条ID作为下次请求的游标
+        if (data.list && data.list.length) {
+          this.lastId = data.list[data.list.length - 1].id
+        }
+        // 存入 globalData 供详情页查找
+        getApp().globalData = getApp().globalData || {}
+        getApp().globalData.circleFeeds = this.feeds
       } catch (e) {
         console.warn('加载动态失败', e)
       }
@@ -230,10 +245,8 @@ export default {
       if (this._navLock) return
       this._navLock = true
       setTimeout(() => { this._navLock = false }, 600)
-      // 根据 friendId 查找对应会话 (f001 -> conv_001)
-      const convId = 'conv_' + friend.id.replace('f', '')
       uni.navigateTo({
-        url: `/pages/chat/chat?friendId=${friend.id}&nickname=${encodeURIComponent(friend.nickname)}&conversationId=${convId}`
+        url: `/pages/chat/chat?friendId=${friend.id}&nickname=${encodeURIComponent(friend.nickname)}`
       })
     },
     goChatList() {
diff --git a/pages/event-create/event-create.vue b/pages/event-create/event-create.vue
index 28d7b2a..98fbc9c 100644
--- a/pages/event-create/event-create.vue
+++ b/pages/event-create/event-create.vue
@@ -115,12 +115,16 @@ export default {
   mixins: [themeMixin],
   data() {
     const menuBtn = uni.getMenuButtonBoundingClientRect()
+    const now = new Date()
+    const pad = n => String(n).padStart(2, '0')
+    const today = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`
+    const curTime = `${pad(now.getHours())}:${pad(now.getMinutes())}`
     return {
       navPaddingTop: menuBtn.top + 'px',
       form: {
         title: '',
-        date: '',
-        time: '',
+        date: today,
+        time: curTime,
         location: '',
         address: '',
         latitude: null,
@@ -200,7 +204,7 @@ export default {
       try {
         await CreateEvent({
           title: this.form.title,
-          time: `${this.form.date} ${this.form.time}`,
+          time: `${this.form.date} ${this.form.time}:00`,
           location: this.form.location,
           address: this.form.address,
           latitude: this.form.latitude,
@@ -211,7 +215,7 @@ export default {
         uni.showToast({ title: '酒局已发布 🎉', icon: 'none' })
         setTimeout(() => uni.navigateBack(), 800)
       } catch (e) {
-        uni.showToast({ title: '发布失败', icon: 'none' })
+        // 全局拦截器已弹出错误提示
       }
       this.submitting = false
     }
diff --git a/pages/event-detail/event-detail.vue b/pages/event-detail/event-detail.vue
index 7314abc..19526f6 100644
--- a/pages/event-detail/event-detail.vue
+++ b/pages/event-detail/event-detail.vue
@@ -98,14 +98,14 @@
     <!-- 底部操作栏 -->
     <view class="evt-action-bar" v-if="event">
       <button
-        v-if="event.status === 'open' && !event.isJoined && !event.isOrganizer"
+        v-if="(event.status === 'open' || event.status === 'upcoming') && !event.isJoined && !event.isOrganizer"
         class="evt-btn evt-btn-primary"
         @click="handleJoin"
       >
         报名参加
       </button>
       <button
-        v-if="event.status === 'open' && event.isJoined && !event.isOrganizer"
+        v-if="(event.status === 'open' || event.status === 'upcoming') && event.isJoined && !event.isOrganizer"
         class="evt-btn evt-btn-ghost"
         @click="handleQuit"
       >
@@ -145,8 +145,9 @@ export default {
   computed: {
     statusLabel() {
       if (!this.event) return ''
-      const map = { open: '报名中', ongoing: '进行中', ended: '已结束' }
-      return map[this.event.status] || '报名中'
+      const val = String(this.event.status).toLowerCase()
+      const map = { open: '报名中', upcoming: '待开始', ongoing: '进行中', ended: '已结束' }
+      return map[val] || '报名中'
     },
     eventMarkers() {
       if (!this.event || !this.event.latitude) return []
@@ -296,6 +297,7 @@ export default {
   margin-bottom: $sp-lg;
 
   &.status-open { background: rgba(94,198,160,0.12); }
+  &.status-upcoming { background: rgba(139,133,184,0.12); }
   &.status-ongoing { background: rgba(232,168,56,0.12); }
   &.status-ended { background: $bg-elevated; }
 }
@@ -305,6 +307,7 @@ export default {
   font-weight: $fw-medium;
 
   .status-open & { color: $mint; }
+  .status-upcoming & { color: $lavender; }
   .status-ongoing & { color: $amber; }
   .status-ended & { color: $text-tertiary; }
 }
diff --git a/pages/record/record.vue b/pages/record/record.vue
index f4e8635..16dca2f 100644
--- a/pages/record/record.vue
+++ b/pages/record/record.vue
@@ -316,7 +316,6 @@ import {
 } from '../../common/constants'
 import { calcStandardCups, unitToMl, formatDate, getCatIcon, isIconPath } from '../../common/utils'
 import client from '../../common/api'
-import { addRecord } from '../../common/mock-data'
 import themeMixin from '../../common/theme-mixin'
 
 export default {
@@ -562,7 +561,13 @@ export default {
         console.warn('创建记录失败，降级本地保存:', e)
         uni.showToast({ title: e.msg || '保存失败，已本地保存', icon: 'none', duration: 2000 })
         // 降级：本地保存
-        const saved = addRecord(recordData)
+        recordData.id = `record_${Date.now()}`
+        recordData.createdAt = new Date().toISOString()
+        let localRecords = []
+        try { localRecords = JSON.parse(uni.getStorageSync('drink_records') || '[]') } catch (e) { /* */ }
+        localRecords.unshift(recordData)
+        uni.setStorageSync('drink_records', JSON.stringify(localRecords))
+        const saved = recordData
         uni.navigateTo({
           url: `/pages/card/card?recordId=${saved.id}`
         })