hejiu/node_modules/HaveADrink/index.d.ts

/*
 * 喝酒了么 - 后端接口 API
 * 小程序：喝酒了么（uni-app 微信小程序）
 * 基础URL: /api/v1
 * 
 * 主要功能模块：
 * 1. 用户模块 - 微信登录、用户信息管理
 * 2. 打卡记录模块 - 饮酒记录创建、查询、日历数据
 * 3. 照片上传模块 - 单张/批量照片上传
 * 4. 统计模块 - 用户统计、月度统计、酒类分布
 * 5. 成就模块 - 成就列表和进度
 * 6. 社交模块 - 朋友圈动态、点赞
 */

export declare interface option {
    value: number | string;
    text: string;
}

/**
 * 枚举类型基类
 */
export declare class Enum {
    constructor(value: number|string);
    toString(): number|string;
    toJSON(): number|string;
    valueOf(): number|string;
}

/**
 * 成就条件类型
 */
export declare class AchievementConditionType extends Enum {
    /**
     * 总记录数
     */
    static TotalRecords: AchievementConditionType;
    /**
     * 累计标准杯
     */
    static TotalStandardCups: AchievementConditionType;
    /**
     * 连续打卡天数
     */
    static StreakDays: AchievementConditionType;
    /**
     * 某酒类打卡次数
     */
    static CategoryRecords: AchievementConditionType;
    /**
     * 尝试酒类品种数
     */
    static CategoryVariety: AchievementConditionType;

    static entries(): Array<option>;
    static getLabel(v: number|string): string;
}

/**
 * 酒类分类
 */
export declare class Category extends Enum {
    /**
     * 白酒
     */
    static Baijiu: Category;
    /**
     * 啤酒
     */
    static Beer: Category;
    /**
     * 红酒
     */
    static Wine: Category;
    /**
     * 洋酒
     */
    static Whisky: Category;
    /**
     * 黄酒
     */
    static Huangjiu: Category;
    /**
     * 清酒
     */
    static Sake: Category;
    /**
     * 果酒
     */
    static Fruit: Category;
    /**
     * 调酒
     */
    static Cocktail: Category;
    /**
     * 其他
     */
    static Other: Category;

    static entries(): Array<option>;
    static getLabel(v: number|string): string;
}

/**
 * 饮用量单位
 */
export declare class Unit extends Enum {
    /**
     * 毫升
     */
    static Ml: Unit;
    /**
     * 两
     */
    static Liang: Unit;
    /**
     * 瓶
     */
    static Bottle: Unit;
    /**
     * 杯
     */
    static Cup: Unit;
    /**
     * 听
     */
    static Can: Unit;
    /**
     * shot
     */
    static Shot: Unit;

    static entries(): Array<option>;
    static getLabel(v: number|string): string;
}

/**
 * 配餐分类
 */
export declare class FoodCategory extends Enum {
    /**
     * 火锅
     */
    static Hotpot: FoodCategory;
    /**
     * 烧烤
     */
    static Bbq: FoodCategory;
    /**
     * 炒菜
     */
    static Stirfry: FoodCategory;
    /**
     * 海鲜
     */
    static Seafood: FoodCategory;
    /**
     * 日料
     */
    static Japanese: FoodCategory;
    /**
     * 西餐
     */
    static Western: FoodCategory;
    /**
     * 小吃卤味
     */
    static Snack: FoodCategory;
    /**
     * 零食
     */
    static Junk: FoodCategory;
    /**
     * 无配餐
     */
    static None: FoodCategory;

    static entries(): Array<option>;
    static getLabel(v: number|string): string;
}

/**
 * 饮用感受
 */
export declare class Feeling extends Enum {
    /**
     * 微醺
     */
    static Tipsy: Feeling;
    /**
     * 到位
     */
    static Buzzed: Feeling;
    /**
     * 醉了
     */
    static Drunk: Feeling;
    /**
     * 断片
     */
    static Blackout: Feeling;

    static entries(): Array<option>;
    static getLabel(v: number|string): string;
}

/**
 * 可见范围
 */
export declare class Visibility extends Enum {
    /**
     * 公开
     */
    static Public: Visibility;
    /**
     * 仅好友
     */
    static Friends: Visibility;
    /**
     * 仅自己
     */
    static Private: Visibility;

    static entries(): Array<option>;
    static getLabel(v: number|string): string;
}

/**
 * 打卡模式
 */
export declare class Mode extends Enum {
    /**
     * 今日喝了
     */
    static Drank: Mode;
    /**
     * 今日未喝
     */
    static Abstain: Mode;

    static entries(): Array<option>;
    static getLabel(v: number|string): string;
}

/**
 * 饮酒频率
 */
export declare class Frequency extends Enum {
    /**
     * 很少
     */
    static Rarely: Frequency;
    /**
     * 有时
     */
    static Sometimes: Frequency;
    /**
     * 经常
     */
    static Often: Frequency;

    static entries(): Array<option>;
    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;
}


/**
 * 手机号
 */
export declare class Phone {
    [key: string]: any;
    /**
     * 区号 (cn +86)
     */
    regin: string
    /**
     * 手机号
     */
    number: string

    /**
     * @param regin string
     * @param number string
     */
    constructor(regin: string, number: string);
}

/**
 * 分页请求参数
 */
export declare class PageReq {
    [key: string]: any;
    /**
    * 页码
    */
    page: number;
    /**
    * 每页数量，默认1-100
    */
    pageSize: number;
    
    /**
     * @param page number  页码
     * @param pageSize number  每页数量，默认1-100
     */
    constructor(page: number,pageSize: number,);
    /**
     * 从对象创建 PageReq
     *
     * @param o Object 
     * - page: number, //  页码
     * - pageSize: number, //  每页数量，默认1-100
     */
    static fromObject(o: Object): PageReq;
}

/**
 * 分页响应结构
 */
export declare class PageResp {
    [key: string]: any;
    /**
    * 总数
    */
    total: number;
    /**
    * 当前页码
    */
    page: number;
    /**
    * 每页数量
    */
    pageSize: number;
    
    /**
     * @param total number  总数
     * @param page number  当前页码
     * @param pageSize number  每页数量
     */
    constructor(total: number,page: number,pageSize: number,);
    /**
     * 从对象创建 PageResp
     *
     * @param o Object 
     * - total: number, //  总数
     * - page: number, //  当前页码
     * - pageSize: number, //  每页数量
     */
    static fromObject(o: Object): PageResp;
}

/**
 * 
 */
export declare class Ok {
    [key: string]: any;
    /**
    * 是否成功
    */
    ok: boolean;
    
    /**
     * @param ok boolean  是否成功
     */
    constructor(ok: boolean,);
    /**
     * 从对象创建 Ok
     *
     * @param o Object 
     * - ok: boolean, //  是否成功
     */
    static fromObject(o: Object): Ok;
}

/**
 * 用于表示无数据
 */
export declare class None {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 None
     *
     * @param o Object 
     */
    static fromObject(o: Object): None;
}

/**
 * 微信登录请求参数
 */
export declare class WechatLoginReq {
    [key: string]: any;
    /**
    * 登录时获取的 code, 可通过 wx.login 获取
    */
    code: string;
    /**
    * 用户昵称
    */
    nickName: string;
    /**
    * 头像URL
    */
    avatarUrl: string;
    
    /**
     * @param code string  登录时获取的 code, 可通过 wx.login 获取
     * @param nickName string  用户昵称
     * @param avatarUrl string  头像URL
     */
    constructor(code: string,nickName: string,avatarUrl: string,);
    /**
     * 从对象创建 WechatLoginReq
     *
     * @param o Object 
     * - code: string, //  登录时获取的 code, 可通过 wx.login 获取
     * - nickName: string, //  用户昵称
     * - avatarUrl: string, //  头像URL
     */
    static fromObject(o: Object): WechatLoginReq;
}

/**
 * 微信登录返回值
 */
export declare class WechatLoginResp {
    [key: string]: any;
    /**
    * JWT Token
    */
    token: string;
    /**
    * 用户信息
    */
    user: User;
    /**
    * 是否新用户
    */
    isNew: boolean;
    /**
    * 会话密钥
    */
    session_key: string;
    /**
    * 用户唯一标识
    */
    open_id: string;
    /**
    * 用户在开放平台的唯一标识符，若当前小程序已绑定到微信开放平台账号下会返回，详见 UnionID 机制说明。
    */
    union_id: string;
    /**
    * 错误码
    */
    errcode: number;
    /**
    * 错误信息
    */
    errmsg: string;
    /**
    * 刷新token
    */
    refresh_token: string;
    
    /**
     * @param token string  JWT Token
     * @param user User  用户信息
     * @param isNew boolean  是否新用户
     * @param session_key string  会话密钥
     * @param open_id string  用户唯一标识
     * @param union_id string  用户在开放平台的唯一标识符，若当前小程序已绑定到微信开放平台账号下会返回，详见 UnionID 机制说明。
     * @param errcode number  错误码
     * @param errmsg string  错误信息
     * @param refresh_token string  刷新token
     */
    constructor(token: string,user: User,isNew: boolean,session_key: string,open_id: string,union_id: string,errcode: number,errmsg: string,refresh_token: string,);
    /**
     * 从对象创建 WechatLoginResp
     *
     * @param o Object 
     * - token: string, //  JWT Token
     * - user: User, //  用户信息
     * - isNew: boolean, //  是否新用户
     * - session_key: string, //  会话密钥
     * - open_id: string, //  用户唯一标识
     * - union_id: string, //  用户在开放平台的唯一标识符，若当前小程序已绑定到微信开放平台账号下会返回，详见 UnionID 机制说明。
     * - errcode: number, //  错误码
     * - errmsg: string, //  错误信息
     * - refresh_token: string, //  刷新token
     */
    static fromObject(o: Object): WechatLoginResp;
}

/**
 * 获取微信手机号
 */
export declare class WechatGetPhoneNumberReq {
    [key: string]: any;
    /**
    * 手机号获取凭证
    */
    code: string;
    
    /**
     * @param code string  手机号获取凭证
     */
    constructor(code: string,);
    /**
     * 从对象创建 WechatGetPhoneNumberReq
     *
     * @param o Object 
     * - code: string, //  手机号获取凭证
     */
    static fromObject(o: Object): WechatGetPhoneNumberReq;
}

/**
 * 获取微信手机号返回值
 */
export declare class WechatGetPhoneNumberResp {
    [key: string]: any;
    /**
    * 错误码
    */
    errcode: number;
    /**
    * 错误信息
    */
    errmsg: string;
    /**
    * token:api使用
    */
    token: string;
    /**
    * token 超时时间，单位（秒）
    */
    expires_in: number;
    /**
    * refresh_token:刷新token
    */
    refresh_token: string;
    
    /**
     * @param errcode number  错误码
     * @param errmsg string  错误信息
     * @param token string  token:api使用
     * @param expires_in number  token 超时时间，单位（秒）
     * @param refresh_token string  refresh_token:刷新token
     */
    constructor(errcode: number,errmsg: string,token: string,expires_in: number,refresh_token: string,);
    /**
     * 从对象创建 WechatGetPhoneNumberResp
     *
     * @param o Object 
     * - errcode: number, //  错误码
     * - errmsg: string, //  错误信息
     * - token: string, //  token:api使用
     * - expires_in: number, //  token 超时时间，单位（秒）
     * - refresh_token: string, //  refresh_token:刷新token
     */
    static fromObject(o: Object): WechatGetPhoneNumberResp;
}

/**
 * 刷新token请求参数
 */
export declare class RefreshTokenReq {
    [key: string]: any;
    /**
    * 签发 token 时生成的 refresh_token
    */
    refresh_token: string;
    
    /**
     * @param refresh_token string  签发 token 时生成的 refresh_token
     */
    constructor(refresh_token: string,);
    /**
     * 从对象创建 RefreshTokenReq
     *
     * @param o Object 
     * - refresh_token: string, //  签发 token 时生成的 refresh_token
     */
    static fromObject(o: Object): RefreshTokenReq;
}

/**
 * 刷新 token 返回值
 */
export declare class RefreshTokenResp {
    [key: string]: any;
    /**
    * 生成的新token
    */
    token: string;
    /**
    * token 超时时间，单位（秒）
    */
    expire_in: number;
    /**
    * refresh_token:刷新token
    */
    refresh_token: string;
    
    /**
     * @param token string  生成的新token
     * @param expire_in number  token 超时时间，单位（秒）
     * @param refresh_token string  refresh_token:刷新token
     */
    constructor(token: string,expire_in: number,refresh_token: string,);
    /**
     * 从对象创建 RefreshTokenResp
     *
     * @param o Object 
     * - token: string, //  生成的新token
     * - expire_in: number, //  token 超时时间，单位（秒）
     * - refresh_token: string, //  refresh_token:刷新token
     */
    static fromObject(o: Object): RefreshTokenResp;
}

/**
 * 成就条件
 */
export declare class AchievementCondition {
    [key: string]: any;
    /**
    * 条件类型
    */
    type: AchievementConditionType;
    /**
    * 目标值
    */
    value: number;
    
    /**
     * @param type AchievementConditionType  条件类型
     * @param value number  目标值
     */
    constructor(type: AchievementConditionType,value: number,);
    /**
     * 从对象创建 AchievementCondition
     *
     * @param o Object 
     * - type: AchievementConditionType, //  条件类型
     * - value: number, //  目标值
     */
    static fromObject(o: Object): AchievementCondition;
}

/**
 * 成就信息
 */
export declare class Achievement {
    [key: string]: any;
    /**
    * 成就ID
    */
    id: string;
    /**
    * 成就名称
    */
    name: string;
    /**
    * 成就描述
    */
    desc: string;
    /**
    * 成就图标
    */
    icon: string;
    /**
    * 是否已解锁
    */
    unlocked: boolean;
    /**
    * 解锁时间
    */
    unlockedAt: string;
    /**
    * 成就条件
    */
    condition: AchievementCondition;
    /**
    * 进度（0-1）
    */
    progress: number;
    
    /**
     * @param id string  成就ID
     * @param name string  成就名称
     * @param desc string  成就描述
     * @param icon string  成就图标
     * @param unlocked boolean  是否已解锁
     * @param unlockedAt string  解锁时间
     * @param condition AchievementCondition  成就条件
     * @param progress number  进度（0-1）
     */
    constructor(id: string,name: string,desc: string,icon: string,unlocked: boolean,unlockedAt: string,condition: AchievementCondition,progress: number,);
    /**
     * 从对象创建 Achievement
     *
     * @param o Object 
     * - id: string, //  成就ID
     * - name: string, //  成就名称
     * - desc: string, //  成就描述
     * - icon: string, //  成就图标
     * - unlocked: boolean, //  是否已解锁
     * - unlockedAt: string, //  解锁时间
     * - condition: AchievementCondition, //  成就条件
     * - progress: number, //  进度（0-1）
     */
    static fromObject(o: Object): Achievement;
}

/**
 * 
 */
export declare class GetAchievementsReq {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 GetAchievementsReq
     *
     * @param o Object 
     */
    static fromObject(o: Object): GetAchievementsReq;
}

/**
 * 获取成就列表响应
 */
export declare class GetAchievementsResp {
    [key: string]: any;
    /**
    * 成就列表数据
    */
    data: AchievementsData;
    
    /**
     * @param data AchievementsData  成就列表数据
     */
    constructor(data: AchievementsData,);
    /**
     * 从对象创建 GetAchievementsResp
     *
     * @param o Object 
     * - data: AchievementsData, //  成就列表数据
     */
    static fromObject(o: Object): GetAchievementsResp;
}

/**
 * 成就列表数据
 */
export declare class AchievementsData {
    [key: string]: any;
    /**
    * 成就列表
    */
    achievements: Array<Achievement>;
    
    /**
     * @param achievements Array<Achievement>  成就列表
     */
    constructor(achievements: Array<Achievement>,);
    /**
     * 从对象创建 AchievementsData
     *
     * @param o Object 
     * - achievements: Array<Achievement>, //  成就列表
     */
    static fromObject(o: Object): AchievementsData;
}

/**
 * 朋友圈动态项
 */
export declare class FeedItem {
    [key: string]: any;
    /**
    * 记录ID
    */
    id: string|number;
    /**
    * 用户信息
    */
    user: FeedUser;
    /**
    * 日期
    */
    date: string;
    /**
    * 打卡模式
    */
    mode: Mode;
    /**
    * 酒水列表
    */
    drinks: Array<DrinkItem>;
    /**
    * 配餐信息
    */
    food: FoodInfo;
    /**
    * 感受
    */
    feeling: Feeling;
    /**
    * 照片URL数组
    */
    photos: Array<string>;
    /**
    * 标准杯总数
    */
    standardCupsTotal: number;
    /**
    * 酒言酒语
    */
    quote: string;
    /**
    * 点赞数
    */
    likeCount: number;
    /**
    * 评论数
    */
    commentCount: number;
    /**
    * 当前用户是否已点赞
    */
    liked: boolean;
    /**
    * 创建时间
    */
    createdAt: string;
    
    /**
     * @param id string|number  记录ID
     * @param user FeedUser  用户信息
     * @param date string  日期
     * @param mode Mode  打卡模式
     * @param drinks Array<DrinkItem>  酒水列表
     * @param food FoodInfo  配餐信息
     * @param feeling Feeling  感受
     * @param photos Array<string>  照片URL数组
     * @param standardCupsTotal number  标准杯总数
     * @param quote string  酒言酒语
     * @param likeCount number  点赞数
     * @param commentCount number  评论数
     * @param liked boolean  当前用户是否已点赞
     * @param createdAt string  创建时间
     */
    constructor(id: string|number,user: FeedUser,date: string,mode: Mode,drinks: Array<DrinkItem>,food: FoodInfo,feeling: Feeling,photos: Array<string>,standardCupsTotal: number,quote: string,likeCount: number,commentCount: number,liked: boolean,createdAt: string,);
    /**
     * 从对象创建 FeedItem
     *
     * @param o Object 
     * - id: string|number, //  记录ID
     * - user: FeedUser, //  用户信息
     * - date: string, //  日期
     * - mode: Mode, //  打卡模式
     * - drinks: Array<DrinkItem>, //  酒水列表
     * - food: FoodInfo, //  配餐信息
     * - feeling: Feeling, //  感受
     * - photos: Array<string>, //  照片URL数组
     * - standardCupsTotal: number, //  标准杯总数
     * - quote: string, //  酒言酒语
     * - likeCount: number, //  点赞数
     * - commentCount: number, //  评论数
     * - liked: boolean, //  当前用户是否已点赞
     * - createdAt: string, //  创建时间
     */
    static fromObject(o: Object): FeedItem;
}

/**
 * 朋友圈用户信息
 */
export declare class FeedUser {
    [key: string]: any;
    /**
    * 用户ID
    */
    id: string|number;
    /**
    * 用户昵称
    */
    nickname: string;
    /**
    * 头像URL
    */
    avatar: string;
    
    /**
     * @param id string|number  用户ID
     * @param nickname string  用户昵称
     * @param avatar string  头像URL
     */
    constructor(id: string|number,nickname: string,avatar: string,);
    /**
     * 从对象创建 FeedUser
     *
     * @param o Object 
     * - id: string|number, //  用户ID
     * - nickname: string, //  用户昵称
     * - avatar: string, //  头像URL
     */
    static fromObject(o: Object): FeedUser;
}

/**
 * 获取朋友圈动态请求
 */
export declare class GetFeedReq {
    [key: string]: any;
    /**
    * 游标分页，上一页最后一条ID
    */
    lastId: string|number;
    
    /**
     * @param lastId string|number  游标分页，上一页最后一条ID
     */
    constructor(lastId: string|number,);
    /**
     * 从对象创建 GetFeedReq
     *
     * @param o Object 
     * - lastId: string|number, //  游标分页，上一页最后一条ID
     */
    static fromObject(o: Object): GetFeedReq;
}

/**
 * 获取朋友圈动态响应
 */
export declare class GetFeedResp {
    [key: string]: any;
    /**
    * 朋友圈动态分页数据
    */
    data: FeedPageData;
    
    /**
     * @param data FeedPageData  朋友圈动态分页数据
     */
    constructor(data: FeedPageData,);
    /**
     * 从对象创建 GetFeedResp
     *
     * @param o Object 
     * - data: FeedPageData, //  朋友圈动态分页数据
     */
    static fromObject(o: Object): GetFeedResp;
}

/**
 * 朋友圈动态分页数据
 */
export declare class FeedPageData {
    [key: string]: any;
    /**
    * 动态列表
    */
    list: Array<FeedItem>;
    
    /**
     * @param list Array<FeedItem>  动态列表
     */
    constructor(list: Array<FeedItem>,);
    /**
     * 从对象创建 FeedPageData
     *
     * @param o Object 
     * - list: Array<FeedItem>, //  动态列表
     */
    static fromObject(o: Object): FeedPageData;
}

/**
 * 上传照片请求
 */
export declare class UploadPhotoReq {
    [key: string]: any;
    /**
    * 图片Url
    */
    url: string;
    /**
    * 关联记录ID
    */
    recordId: string|number;
    
    /**
     * @param url string  图片Url
     * @param recordId string|number  关联记录ID
     */
    constructor(url: string,recordId: string|number,);
    /**
     * 从对象创建 UploadPhotoReq
     *
     * @param o Object 
     * - url: string, //  图片Url
     * - recordId: string|number, //  关联记录ID
     */
    static fromObject(o: Object): UploadPhotoReq;
}

/**
 * 上传照片响应
 */
export declare class UploadPhotoResp {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 UploadPhotoResp
     *
     * @param o Object 
     */
    static fromObject(o: Object): UploadPhotoResp;
}

/**
 * 批量上传照片请求
 */
export declare class UploadPhotosReq {
    [key: string]: any;
    /**
    * 图片URL数组（最多9张）
    */
    urls: Array<string>;
    /**
    * 关联记录ID
    */
    recordId: string|number;
    
    /**
     * @param urls Array<string>  图片URL数组（最多9张）
     * @param recordId string|number  关联记录ID
     */
    constructor(urls: Array<string>,recordId: string|number,);
    /**
     * 从对象创建 UploadPhotosReq
     *
     * @param o Object 
     * - urls: Array<string>, //  图片URL数组（最多9张）
     * - recordId: string|number, //  关联记录ID
     */
    static fromObject(o: Object): UploadPhotosReq;
}

/**
 * 批量上传照片响应
 */
export declare class UploadPhotosResp {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 UploadPhotosResp
     *
     * @param o Object 
     */
    static fromObject(o: Object): UploadPhotosResp;
}

/**
 * 酒水项
 */
export declare class DrinkItem {
    [key: string]: any;
    /**
    * 酒类分类ID
    */
    category: Category;
    /**
    * 品牌名称
    */
    brand: string;
    /**
    * 产品名
    */
    product: string;
    /**
    * 饮用量数值
    */
    amount: number;
    /**
    * 单位
    */
    unit: Unit;
    /**
    * 酒精度数(%)
    */
    degree: number;
    /**
    * 标准杯数（前端计算，后端应校验）
    */
    standardCups: number;
    /**
    * 自定义饮酒数量
    */
    customAmount: number;
    /**
    * 自定义饮酒单位
    */
    customUnit: Unit;
    
    /**
     * @param category Category  酒类分类ID
     * @param brand string  品牌名称
     * @param product string  产品名
     * @param amount number  饮用量数值
     * @param unit Unit  单位
     * @param degree number  酒精度数(%)
     * @param standardCups number  标准杯数（前端计算，后端应校验）
     * @param customAmount number  自定义饮酒数量
     * @param customUnit Unit  自定义饮酒单位
     */
    constructor(category: Category,brand: string,product: string,amount: number,unit: Unit,degree: number,standardCups: number,customAmount: number,customUnit: Unit,);
    /**
     * 从对象创建 DrinkItem
     *
     * @param o Object 
     * - category: Category, //  酒类分类ID
     * - brand: string, //  品牌名称
     * - product: string, //  产品名
     * - amount: number, //  饮用量数值
     * - unit: Unit, //  单位
     * - degree: number, //  酒精度数(%)
     * - standardCups: number, //  标准杯数（前端计算，后端应校验）
     * - customAmount: number, //  自定义饮酒数量
     * - customUnit: Unit, //  自定义饮酒单位
     */
    static fromObject(o: Object): DrinkItem;
}

/**
 * 配餐信息
 */
export declare class FoodInfo {
    [key: string]: any;
    /**
    * 配餐分类ID
    */
    category: FoodCategory;
    /**
    * 具体菜名
    */
    name: string;
    
    /**
     * @param category FoodCategory  配餐分类ID
     * @param name string  具体菜名
     */
    constructor(category: FoodCategory,name: string,);
    /**
     * 从对象创建 FoodInfo
     *
     * @param o Object 
     * - category: FoodCategory, //  配餐分类ID
     * - name: string, //  具体菜名
     */
    static fromObject(o: Object): FoodInfo;
}

/**
 * 创建打卡记录请求
 */
export declare class CreateRecordReq {
    [key: string]: any;
    /**
    * 日期 YYYY-MM-DD
    */
    date: string;
    /**
    * 打卡模式
    */
    mode: Mode;
    /**
    * 酒水列表（mode=abstain时为空数组）
    */
    drinks: Array<DrinkItem>;
    /**
    * 配餐信息
    */
    food: FoodInfo;
    /**
    * 感受ID
    */
    feeling: Feeling;
    /**
    * 照片URL数组（最多9张）
    */
    photos: Array<string>;
    /**
    * 可见范围
    */
    visibility: Visibility;
    /**
    * 酒言酒语
    */
    quote: string;
    
    /**
     * @param date string  日期 YYYY-MM-DD
     * @param mode Mode  打卡模式
     * @param drinks Array<DrinkItem>  酒水列表（mode=abstain时为空数组）
     * @param food FoodInfo  配餐信息
     * @param feeling Feeling  感受ID
     * @param photos Array<string>  照片URL数组（最多9张）
     * @param visibility Visibility  可见范围
     * @param quote string  酒言酒语
     */
    constructor(date: string,mode: Mode,drinks: Array<DrinkItem>,food: FoodInfo,feeling: Feeling,photos: Array<string>,visibility: Visibility,quote: string,);
    /**
     * 从对象创建 CreateRecordReq
     *
     * @param o Object 
     * - date: string, //  日期 YYYY-MM-DD
     * - mode: Mode, //  打卡模式
     * - drinks: Array<DrinkItem>, //  酒水列表（mode=abstain时为空数组）
     * - food: FoodInfo, //  配餐信息
     * - feeling: Feeling, //  感受ID
     * - photos: Array<string>, //  照片URL数组（最多9张）
     * - visibility: Visibility, //  可见范围
     * - quote: string, //  酒言酒语
     */
    static fromObject(o: Object): CreateRecordReq;
}

/**
 * 打卡记录详情
 */
export declare class Record {
    [key: string]: any;
    /**
    * 记录ID
    */
    id: string|number;
    /**
    * 日期
    */
    date: string;
    /**
    * 打卡模式
    */
    mode: Mode;
    /**
    * 酒水列表
    */
    drinks: Array<DrinkItem>;
    /**
    * 配餐信息
    */
    food: FoodInfo;
    /**
    * 感受
    */
    feeling: Feeling;
    /**
    * 照片URL数组
    */
    photos: Array<string>;
    /**
    * 可见范围
    */
    visibility: Visibility;
    /**
    * 酒言酒语
    */
    quote: string;
    /**
    * 标准杯总数
    */
    standardCupsTotal: number;
    /**
    * 创建时间
    */
    createdAt: string;
    
    /**
     * @param id string|number  记录ID
     * @param date string  日期
     * @param mode Mode  打卡模式
     * @param drinks Array<DrinkItem>  酒水列表
     * @param food FoodInfo  配餐信息
     * @param feeling Feeling  感受
     * @param photos Array<string>  照片URL数组
     * @param visibility Visibility  可见范围
     * @param quote string  酒言酒语
     * @param standardCupsTotal number  标准杯总数
     * @param createdAt string  创建时间
     */
    constructor(id: string|number,date: string,mode: Mode,drinks: Array<DrinkItem>,food: FoodInfo,feeling: Feeling,photos: Array<string>,visibility: Visibility,quote: string,standardCupsTotal: number,createdAt: string,);
    /**
     * 从对象创建 Record
     *
     * @param o Object 
     * - id: string|number, //  记录ID
     * - date: string, //  日期
     * - mode: Mode, //  打卡模式
     * - drinks: Array<DrinkItem>, //  酒水列表
     * - food: FoodInfo, //  配餐信息
     * - feeling: Feeling, //  感受
     * - photos: Array<string>, //  照片URL数组
     * - visibility: Visibility, //  可见范围
     * - quote: string, //  酒言酒语
     * - standardCupsTotal: number, //  标准杯总数
     * - createdAt: string, //  创建时间
     */
    static fromObject(o: Object): Record;
}

/**
 * 创建打卡记录响应
 */
export declare class CreateRecordResp {
    [key: string]: any;
    /**
    * 创建的记录详情
    */
    data: Record;
    
    /**
     * @param data Record  创建的记录详情
     */
    constructor(data: Record,);
    /**
     * 从对象创建 CreateRecordResp
     *
     * @param o Object 
     * - data: Record, //  创建的记录详情
     */
    static fromObject(o: Object): CreateRecordResp;
}

/**
 * 获取记录列表请求
 */
export declare class GetRecordsReq {
    [key: string]: any;
    /**
    * 页码
    */
    page: number;
    /**
    * 每页数量，默认1-100
    */
    pageSize: number;
    /**
    * 月份筛选 YYYY-MM
    */
    month: string;
    /**
    * 打卡模式筛选
    */
    mode: Mode;
    
    /**
     * @param page number  页码
     * @param pageSize number  每页数量，默认1-100
     * @param month string  月份筛选 YYYY-MM
     * @param mode Mode  打卡模式筛选
     */
    constructor(page: number,pageSize: number,month: string,mode: Mode,);
    /**
     * 从对象创建 GetRecordsReq
     *
     * @param o Object 
     * - page: number, //  页码
     * - pageSize: number, //  每页数量，默认1-100
     * - month: string, //  月份筛选 YYYY-MM
     * - mode: Mode, //  打卡模式筛选
     */
    static fromObject(o: Object): GetRecordsReq;
}

/**
 * 获取记录列表响应
 */
export declare class GetRecordsResp {
    [key: string]: any;
    /**
    * 分页数据
    */
    list: Array<Record>;
    
    /**
     * @param list Array<Record>  分页数据
     */
    constructor(list: Array<Record>,);
    /**
     * 从对象创建 GetRecordsResp
     *
     * @param o Object 
     * - list: Array<Record>, //  分页数据
     */
    static fromObject(o: Object): GetRecordsResp;
}

/**
 * 获取单条记录详情请求
 */
export declare class GetRecordDetailReq {
    [key: string]: any;
    /**
    * 记录ID
    */
    id: string|number;
    
    /**
     * @param id string|number  记录ID
     */
    constructor(id: string|number,);
    /**
     * 从对象创建 GetRecordDetailReq
     *
     * @param o Object 
     * - id: string|number, //  记录ID
     */
    static fromObject(o: Object): GetRecordDetailReq;
}

/**
 * 获取单条记录详情响应
 */
export declare class GetRecordDetailResp {
    [key: string]: any;
    /**
    * 记录详情
    */
    data: Record;
    
    /**
     * @param data Record  记录详情
     */
    constructor(data: Record,);
    /**
     * 从对象创建 GetRecordDetailResp
     *
     * @param o Object 
     * - data: Record, //  记录详情
     */
    static fromObject(o: Object): GetRecordDetailResp;
}

/**
 * 删除记录请求
 */
export declare class DeleteRecordReq {
    [key: string]: any;
    /**
    * 记录ID
    */
    id: string|number;
    
    /**
     * @param id string|number  记录ID
     */
    constructor(id: string|number,);
    /**
     * 从对象创建 DeleteRecordReq
     *
     * @param o Object 
     * - id: string|number, //  记录ID
     */
    static fromObject(o: Object): DeleteRecordReq;
}

/**
 * 删除记录响应
 */
export declare class DeleteRecordResp {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 DeleteRecordResp
     *
     * @param o Object 
     */
    static fromObject(o: Object): DeleteRecordResp;
}

/**
 * 获取日历打卡数据请求
 */
export declare class GetCalendarReq {
    [key: string]: any;
    /**
    * 年份
    */
    year: number;
    /**
    * 月份(1-12)
    */
    month: number;
    
    /**
     * @param year number  年份
     * @param month number  月份(1-12)
     */
    constructor(year: number,month: number,);
    /**
     * 从对象创建 GetCalendarReq
     *
     * @param o Object 
     * - year: number, //  年份
     * - month: number, //  月份(1-12)
     */
    static fromObject(o: Object): GetCalendarReq;
}

/**
 * 日历打卡数据
 */
export declare class CalendarData {
    [key: string]: any;
    /**
    * 年份
    */
    year: number;
    /**
    * 月份
    */
    month: number;
    /**
    * 每天的打卡数据，null表示当天无记录
    */
    days: Array<CalendarDayData>;
    
    /**
     * @param year number  年份
     * @param month number  月份
     * @param days Array<CalendarDayData>  每天的打卡数据，null表示当天无记录
     */
    constructor(year: number,month: number,days: Array<CalendarDayData>,);
    /**
     * 从对象创建 CalendarData
     *
     * @param o Object 
     * - year: number, //  年份
     * - month: number, //  月份
     * - days: Array<CalendarDayData>, //  每天的打卡数据，null表示当天无记录
     */
    static fromObject(o: Object): CalendarData;
}

/**
 * 日历单日打卡数据
 */
export declare class CalendarDayData {
    [key: string]: any;
    /**
    * 日期YYYY-MM-DD
    */
    date: string;
    /**
    * 是否有记录
    */
    hasRecord: boolean;
    /**
    * 打卡模式
    */
    mode: Mode;
    /**
    * 标准杯总数
    */
    standardCupsTotal: number;
    /**
    * 记录ID
    */
    id: string|number;
    /**
    * 酒水列表
    */
    drinks: Array<DrinkItem>;
    /**
    * 配餐信息
    */
    food: FoodInfo;
    /**
    * 感受
    */
    feeling: Feeling;
    /**
    * 照片URL数组
    */
    photos: Array<string>;
    /**
    * 可见范围
    */
    visibility: Visibility;
    /**
    * 酒言酒语
    */
    quote: string;
    /**
    * 创建时间
    */
    createdAt: string;
    
    /**
     * @param date string  日期YYYY-MM-DD
     * @param hasRecord boolean  是否有记录
     * @param mode Mode  打卡模式
     * @param standardCupsTotal number  标准杯总数
     * @param id string|number  记录ID
     * @param drinks Array<DrinkItem>  酒水列表
     * @param food FoodInfo  配餐信息
     * @param feeling Feeling  感受
     * @param photos Array<string>  照片URL数组
     * @param visibility Visibility  可见范围
     * @param quote string  酒言酒语
     * @param createdAt string  创建时间
     */
    constructor(date: string,hasRecord: boolean,mode: Mode,standardCupsTotal: number,id: string|number,drinks: Array<DrinkItem>,food: FoodInfo,feeling: Feeling,photos: Array<string>,visibility: Visibility,quote: string,createdAt: string,);
    /**
     * 从对象创建 CalendarDayData
     *
     * @param o Object 
     * - date: string, //  日期YYYY-MM-DD
     * - hasRecord: boolean, //  是否有记录
     * - mode: Mode, //  打卡模式
     * - standardCupsTotal: number, //  标准杯总数
     * - id: string|number, //  记录ID
     * - drinks: Array<DrinkItem>, //  酒水列表
     * - food: FoodInfo, //  配餐信息
     * - feeling: Feeling, //  感受
     * - photos: Array<string>, //  照片URL数组
     * - visibility: Visibility, //  可见范围
     * - quote: string, //  酒言酒语
     * - createdAt: string, //  创建时间
     */
    static fromObject(o: Object): CalendarDayData;
}

/**
 * 获取日历打卡数据响应
 */
export declare class GetCalendarResp {
    [key: string]: any;
    /**
    * 年份
    */
    year: number;
    /**
    * 月份
    */
    month: number;
    /**
    * 每天的打卡数据，null表示当天无记录
    */
    days: Array<CalendarDayData>;
    
    /**
     * @param year number  年份
     * @param month number  月份
     * @param days Array<CalendarDayData>  每天的打卡数据，null表示当天无记录
     */
    constructor(year: number,month: number,days: Array<CalendarDayData>,);
    /**
     * 从对象创建 GetCalendarResp
     *
     * @param o Object 
     * - year: number, //  年份
     * - month: number, //  月份
     * - days: Array<CalendarDayData>, //  每天的打卡数据，null表示当天无记录
     */
    static fromObject(o: Object): GetCalendarResp;
}

/**
 * 用户统计概览数据
 */
export declare class StatsOverview {
    [key: string]: any;
    /**
    * 本周饮酒天数
    */
    weekDrinkCount: number;
    /**
    * 本周标准杯总数
    */
    weekCups: number;
    /**
    * 本月饮酒天数
    */
    monthDrinkCount: number;
    /**
    * 本月标准杯总数
    */
    monthCups: number;
    /**
    * 当前连续打卡天数
    */
    streak: number;
    /**
    * 连续类型
    */
    streakType: Mode;
    /**
    * 总饮酒天数（去重）
    */
    totalDays: number;
    /**
    * 总记录数
    */
    totalRecords: number;
    /**
    * 历史累计标准杯
    */
    totalCups: number;
    /**
    * 最爱酒类ID
    */
    favCategory: Category;
    /**
    * 尝试过的酒类品种数
    */
    categoryVariety: number;
    
    /**
     * @param weekDrinkCount number  本周饮酒天数
     * @param weekCups number  本周标准杯总数
     * @param monthDrinkCount number  本月饮酒天数
     * @param monthCups number  本月标准杯总数
     * @param streak number  当前连续打卡天数
     * @param streakType Mode  连续类型
     * @param totalDays number  总饮酒天数（去重）
     * @param totalRecords number  总记录数
     * @param totalCups number  历史累计标准杯
     * @param favCategory Category  最爱酒类ID
     * @param categoryVariety number  尝试过的酒类品种数
     */
    constructor(weekDrinkCount: number,weekCups: number,monthDrinkCount: number,monthCups: number,streak: number,streakType: Mode,totalDays: number,totalRecords: number,totalCups: number,favCategory: Category,categoryVariety: number,);
    /**
     * 从对象创建 StatsOverview
     *
     * @param o Object 
     * - weekDrinkCount: number, //  本周饮酒天数
     * - weekCups: number, //  本周标准杯总数
     * - monthDrinkCount: number, //  本月饮酒天数
     * - monthCups: number, //  本月标准杯总数
     * - streak: number, //  当前连续打卡天数
     * - streakType: Mode, //  连续类型
     * - totalDays: number, //  总饮酒天数（去重）
     * - totalRecords: number, //  总记录数
     * - totalCups: number, //  历史累计标准杯
     * - favCategory: Category, //  最爱酒类ID
     * - categoryVariety: number, //  尝试过的酒类品种数
     */
    static fromObject(o: Object): StatsOverview;
}

/**
 * 获取用户统计概览响应
 */
export declare class GetStatsOverviewResp {
    [key: string]: any;
    /**
    * 统计概览数据
    */
    data: StatsOverview;
    
    /**
     * @param data StatsOverview  统计概览数据
     */
    constructor(data: StatsOverview,);
    /**
     * 从对象创建 GetStatsOverviewResp
     *
     * @param o Object 
     * - data: StatsOverview, //  统计概览数据
     */
    static fromObject(o: Object): GetStatsOverviewResp;
}

/**
 * 获取月度统计请求
 */
export declare class GetMonthlyStatsReq {
    [key: string]: any;
    /**
    * 年份，默认当前年
    */
    year: number;
    /**
    * 月份，默认当前月
    */
    month: number;
    
    /**
     * @param year number  年份，默认当前年
     * @param month number  月份，默认当前月
     */
    constructor(year: number,month: number,);
    /**
     * 从对象创建 GetMonthlyStatsReq
     *
     * @param o Object 
     * - year: number, //  年份，默认当前年
     * - month: number, //  月份，默认当前月
     */
    static fromObject(o: Object): GetMonthlyStatsReq;
}

/**
 * 月度统计数据
 */
export declare class MonthlyStats {
    [key: string]: any;
    /**
    * 年份
    */
    year: number;
    /**
    * 月份
    */
    month: number;
    /**
    * 饮酒天数
    */
    drinkDays: number;
    /**
    * 戒酒天数
    */
    abstainDays: number;
    /**
    * 总标准杯数
    */
    totalCups: number;
    /**
    * 日均标准杯数
    */
    avgCupsPerDay: number;
    /**
    * 酒类分布
    */
    categoryBreakdown: Array<CategoryBreakdown>;
    /**
    * 感受分布
    */
    feelingBreakdown: Array<FeelingBreakdown>;
    /**
    * 配餐分布
    */
    foodBreakdown: Array<FoodBreakdown>;
    
    /**
     * @param year number  年份
     * @param month number  月份
     * @param drinkDays number  饮酒天数
     * @param abstainDays number  戒酒天数
     * @param totalCups number  总标准杯数
     * @param avgCupsPerDay number  日均标准杯数
     * @param categoryBreakdown Array<CategoryBreakdown>  酒类分布
     * @param feelingBreakdown Array<FeelingBreakdown>  感受分布
     * @param foodBreakdown Array<FoodBreakdown>  配餐分布
     */
    constructor(year: number,month: number,drinkDays: number,abstainDays: number,totalCups: number,avgCupsPerDay: number,categoryBreakdown: Array<CategoryBreakdown>,feelingBreakdown: Array<FeelingBreakdown>,foodBreakdown: Array<FoodBreakdown>,);
    /**
     * 从对象创建 MonthlyStats
     *
     * @param o Object 
     * - year: number, //  年份
     * - month: number, //  月份
     * - drinkDays: number, //  饮酒天数
     * - abstainDays: number, //  戒酒天数
     * - totalCups: number, //  总标准杯数
     * - avgCupsPerDay: number, //  日均标准杯数
     * - categoryBreakdown: Array<CategoryBreakdown>, //  酒类分布
     * - feelingBreakdown: Array<FeelingBreakdown>, //  感受分布
     * - foodBreakdown: Array<FoodBreakdown>, //  配餐分布
     */
    static fromObject(o: Object): MonthlyStats;
}

/**
 * 酒类分布统计项
 */
export declare class CategoryBreakdown {
    [key: string]: any;
    /**
    * 酒类分类
    */
    category: Category;
    /**
    * 次数
    */
    count: number;
    /**
    * 标准杯数
    */
    cups: number;
    
    /**
     * @param category Category  酒类分类
     * @param count number  次数
     * @param cups number  标准杯数
     */
    constructor(category: Category,count: number,cups: number,);
    /**
     * 从对象创建 CategoryBreakdown
     *
     * @param o Object 
     * - category: Category, //  酒类分类
     * - count: number, //  次数
     * - cups: number, //  标准杯数
     */
    static fromObject(o: Object): CategoryBreakdown;
}

/**
 * 感受分布统计项
 */
export declare class FeelingBreakdown {
    [key: string]: any;
    /**
    * 感受类型
    */
    feeling: Feeling;
    /**
    * 次数
    */
    count: number;
    
    /**
     * @param feeling Feeling  感受类型
     * @param count number  次数
     */
    constructor(feeling: Feeling,count: number,);
    /**
     * 从对象创建 FeelingBreakdown
     *
     * @param o Object 
     * - feeling: Feeling, //  感受类型
     * - count: number, //  次数
     */
    static fromObject(o: Object): FeelingBreakdown;
}

/**
 * 配餐分布统计项
 */
export declare class FoodBreakdown {
    [key: string]: any;
    /**
    * 配餐分类
    */
    category: FoodCategory;
    /**
    * 次数
    */
    count: number;
    
    /**
     * @param category FoodCategory  配餐分类
     * @param count number  次数
     */
    constructor(category: FoodCategory,count: number,);
    /**
     * 从对象创建 FoodBreakdown
     *
     * @param o Object 
     * - category: FoodCategory, //  配餐分类
     * - count: number, //  次数
     */
    static fromObject(o: Object): FoodBreakdown;
}

/**
 * 获取月度统计响应
 */
export declare class GetMonthlyStatsResp {
    [key: string]: any;
    /**
    * 月度统计数据
    */
    data: MonthlyStats;
    
    /**
     * @param data MonthlyStats  月度统计数据
     */
    constructor(data: MonthlyStats,);
    /**
     * 从对象创建 GetMonthlyStatsResp
     *
     * @param o Object 
     * - data: MonthlyStats, //  月度统计数据
     */
    static fromObject(o: Object): GetMonthlyStatsResp;
}

/**
 * 酒类分布统计项
 */
export declare class CategoryStats {
    [key: string]: any;
    /**
    * 酒类分类ID
    */
    id: Category;
    /**
    * 酒类名称
    */
    name: string;
    /**
    * 记录次数
    */
    recordCount: number;
    /**
    * 总标准杯数
    */
    totalCups: number;
    /**
    * 占比（百分比）
    */
    percentage: number;
    
    /**
     * @param id Category  酒类分类ID
     * @param name string  酒类名称
     * @param recordCount number  记录次数
     * @param totalCups number  总标准杯数
     * @param percentage number  占比（百分比）
     */
    constructor(id: Category,name: string,recordCount: number,totalCups: number,percentage: number,);
    /**
     * 从对象创建 CategoryStats
     *
     * @param o Object 
     * - id: Category, //  酒类分类ID
     * - name: string, //  酒类名称
     * - recordCount: number, //  记录次数
     * - totalCups: number, //  总标准杯数
     * - percentage: number, //  占比（百分比）
     */
    static fromObject(o: Object): CategoryStats;
}

/**
 * 
 */
export declare class GetStatsOverviewReq {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 GetStatsOverviewReq
     *
     * @param o Object 
     */
    static fromObject(o: Object): GetStatsOverviewReq;
}

/**
 * 
 */
export declare class GetCategoryStatsReq {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 GetCategoryStatsReq
     *
     * @param o Object 
     */
    static fromObject(o: Object): GetCategoryStatsReq;
}

/**
 * 获取酒类分布统计响应
 */
export declare class GetCategoryStatsResp {
    [key: string]: any;
    /**
    * 酒类分布统计数据
    */
    data: CategoryStatsData;
    
    /**
     * @param data CategoryStatsData  酒类分布统计数据
     */
    constructor(data: CategoryStatsData,);
    /**
     * 从对象创建 GetCategoryStatsResp
     *
     * @param o Object 
     * - data: CategoryStatsData, //  酒类分布统计数据
     */
    static fromObject(o: Object): GetCategoryStatsResp;
}

/**
 * 酒类分布统计数据
 */
export declare class CategoryStatsData {
    [key: string]: any;
    /**
    * 酒类分布列表
    */
    categories: Array<CategoryStats>;
    
    /**
     * @param categories Array<CategoryStats>  酒类分布列表
     */
    constructor(categories: Array<CategoryStats>,);
    /**
     * 从对象创建 CategoryStatsData
     *
     * @param o Object 
     * - categories: Array<CategoryStats>, //  酒类分布列表
     */
    static fromObject(o: Object): CategoryStatsData;
}

/**
 * 用户信息
 */
export declare class User {
    [key: string]: any;
    /**
    * 用户ID
    */
    id: string|number;
    /**
    * 用户昵称
    */
    nickname: string;
    /**
    * 头像URL
    */
    avatar: string;
    /**
    * 加入时间
    */
    joinedAt: string;
    /**
    * 用户偏好
    */
    preferences: UserPreferences;
    
    /**
     * @param id string|number  用户ID
     * @param nickname string  用户昵称
     * @param avatar string  头像URL
     * @param joinedAt string  加入时间
     * @param preferences UserPreferences  用户偏好
     */
    constructor(id: string|number,nickname: string,avatar: string,joinedAt: string,preferences: UserPreferences,);
    /**
     * 从对象创建 User
     *
     * @param o Object 
     * - id: string|number, //  用户ID
     * - nickname: string, //  用户昵称
     * - avatar: string, //  头像URL
     * - joinedAt: string, //  加入时间
     * - preferences: UserPreferences, //  用户偏好
     */
    static fromObject(o: Object): User;
}

/**
 * 用户偏好设置
 */
export declare class UserPreferences {
    [key: string]: any;
    /**
    * 偏好酒类ID列表
    */
    favoriteCategories: Array<Category>;
    /**
    * 饮酒频率
    */
    frequency: Frequency;
    
    /**
     * @param favoriteCategories Array<Category>  偏好酒类ID列表
     * @param frequency Frequency  饮酒频率
     */
    constructor(favoriteCategories: Array<Category>,frequency: Frequency,);
    /**
     * 从对象创建 UserPreferences
     *
     * @param o Object 
     * - favoriteCategories: Array<Category>, //  偏好酒类ID列表
     * - frequency: Frequency, //  饮酒频率
     */
    static fromObject(o: Object): UserPreferences;
}

/**
 * 获取用户信息请求
 */
export declare class GetUserProfileReq {
    [key: string]: any;
    
    /**
     */
    constructor();
    /**
     * 从对象创建 GetUserProfileReq
     *
     * @param o Object 
     */
    static fromObject(o: Object): GetUserProfileReq;
}

/**
 * 获取用户信息响应
 */
export declare class GetUserProfileResp {
    [key: string]: any;
    /**
    * 用户ID
    */
    id: string|number;
    /**
    * 用户昵称
    */
    nickname: string;
    /**
    * 头像URL
    */
    avatar: string;
    /**
    * 加入时间
    */
    joinedAt: string;
    /**
    * 用户偏好
    */
    preferences: UserPreferences;
    
    /**
     * @param id string|number  用户ID
     * @param nickname string  用户昵称
     * @param avatar string  头像URL
     * @param joinedAt string  加入时间
     * @param preferences UserPreferences  用户偏好
     */
    constructor(id: string|number,nickname: string,avatar: string,joinedAt: string,preferences: UserPreferences,);
    /**
     * 从对象创建 GetUserProfileResp
     *
     * @param o Object 
     * - id: string|number, //  用户ID
     * - nickname: string, //  用户昵称
     * - avatar: string, //  头像URL
     * - joinedAt: string, //  加入时间
     * - preferences: UserPreferences, //  用户偏好
     */
    static fromObject(o: Object): GetUserProfileResp;
}

/**
 * 更新用户偏好请求
 */
export declare class UpdatePreferencesReq {
    [key: string]: any;
    /**
    * 偏好酒类ID列表
    */
    favoriteCategories: Array<Category>;
    /**
    * 饮酒频率
    */
    frequency: Frequency;
    
    /**
     * @param favoriteCategories Array<Category>  偏好酒类ID列表
     * @param frequency Frequency  饮酒频率
     */
    constructor(favoriteCategories: Array<Category>,frequency: Frequency,);
    /**
     * 从对象创建 UpdatePreferencesReq
     *
     * @param o Object 
     * - favoriteCategories: Array<Category>, //  偏好酒类ID列表
     * - frequency: Frequency, //  饮酒频率
     */
    static fromObject(o: Object): UpdatePreferencesReq;
}

/**
 * 更新用户偏好响应
 */
export declare class UpdatePreferencesResp {
    [key: string]: any;
    /**
    * 偏好酒类ID列表
    */
    favoriteCategories: Array<Category>;
    /**
    * 饮酒频率
    */
    frequency: Frequency;
    
    /**
     * @param favoriteCategories Array<Category>  偏好酒类ID列表
     * @param frequency Frequency  饮酒频率
     */
    constructor(favoriteCategories: Array<Category>,frequency: Frequency,);
    /**
     * 从对象创建 UpdatePreferencesResp
     *
     * @param o Object 
     * - favoriteCategories: Array<Category>, //  偏好酒类ID列表
     * - frequency: Frequency, //  饮酒频率
     */
    static fromObject(o: Object): UpdatePreferencesResp;
}

/**
 * 上传图片参数
 */
export declare class UploadImageReq {
    [key: string]: any;
    /**
    * 图片
    */
    image: any;
    
    /**
     * @param image any  图片
     */
    constructor(image: any,);
    /**
     * 从对象创建 UploadImageReq
     *
     * @param o Object 
     * - image: any, //  图片
     */
    static fromObject(o: Object): UploadImageReq;
}

/**
 * 上传图片返回
 */
export declare class UploadImageResp {
    [key: string]: any;
    /**
    * 图片 id
    */
    id: string|number;
    /**
    * 图片 url
    */
    url: string;
    
    /**
     * @param id string|number  图片 id
     * @param url string  图片 url
     */
    constructor(id: string|number,url: string,);
    /**
     * 从对象创建 UploadImageResp
     *
     * @param o Object 
     * - id: string|number, //  图片 id
     * - url: string, //  图片 url
     */
    static fromObject(o: Object): UploadImageResp;
}

/**
 * 引用文件参数
 */
export declare class ReferenceFileReq {
    [key: string]: any;
    /**
    * 模块名称
    */
    module: string;
    /**
    * 数据 id
    */
    data: number;
    /**
    * 文件 urls
    */
    urls: Array<string>;
    
    /**
     * @param module string  模块名称
     * @param data number  数据 id
     * @param urls Array<string>  文件 urls
     */
    constructor(module: string,data: number,urls: Array<string>,);
    /**
     * 从对象创建 ReferenceFileReq
     *
     * @param o Object 
     * - module: string, //  模块名称
     * - data: number, //  数据 id
     * - urls: Array<string>, //  文件 urls
     */
    static fromObject(o: Object): ReferenceFileReq;
}

/**
 * 引用文件返回
 */
export declare class ReferenceFileResp {
    [key: string]: any;
    /**
    * 是否成功
    */
    ok: boolean;
    
    /**
     * @param ok boolean  是否成功
     */
    constructor(ok: boolean,);
    /**
     * 从对象创建 ReferenceFileResp
     *
     * @param o Object 
     * - ok: boolean, //  是否成功
     */
    static fromObject(o: Object): ReferenceFileResp;
}

/**
 * 取消引用文件参数
 */
export declare class DereferenceFileReq {
    [key: string]: any;
    /**
    * 模块
    */
    module: string;
    /**
    * 数据 id
    */
    data: number;
    /**
    * 文件 urls
    */
    urls: Array<string>;
    
    /**
     * @param module string  模块
     * @param data number  数据 id
     * @param urls Array<string>  文件 urls
     */
    constructor(module: string,data: number,urls: Array<string>,);
    /**
     * 从对象创建 DereferenceFileReq
     *
     * @param o Object 
     * - module: string, //  模块
     * - data: number, //  数据 id
     * - urls: Array<string>, //  文件 urls
     */
    static fromObject(o: Object): DereferenceFileReq;
}

/**
 * 取消引用文件返回
 */
export declare class DereferenceFileResp {
    [key: string]: any;
    /**
    * 是否成功
    */
    ok: boolean;
    
    /**
     * @param ok boolean  是否成功
     */
    constructor(ok: boolean,);
    /**
     * 从对象创建 DereferenceFileResp
     *
     * @param o Object 
     * - ok: boolean, //  是否成功
     */
    static fromObject(o: Object): DereferenceFileResp;
}

/**
 * 删除数据参数
 */
export declare class DeleteDataReq {
    [key: string]: any;
    /**
    * 模块
    */
    module: string;
    /**
    * 数据 id
    */
    data: number;
    
    /**
     * @param module string  模块
     * @param data number  数据 id
     */
    constructor(module: string,data: number,);
    /**
     * 从对象创建 DeleteDataReq
     *
     * @param o Object 
     * - module: string, //  模块
     * - data: number, //  数据 id
     */
    static fromObject(o: Object): DeleteDataReq;
}

/**
 * 删除数据返回
 */
export declare class DeleteDataResp {
    [key: string]: any;
    /**
    * 是否成功
    */
    ok: boolean;
    
    /**
     * @param ok boolean  是否成功
     */
    constructor(ok: boolean,);
    /**
     * 从对象创建 DeleteDataResp
     *
     * @param o Object 
     * - ok: boolean, //  是否成功
     */
    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
 * 小程序：喝酒了么（uni-app 微信小程序）
 * 基础URL: /api/v1
 * 
 * 主要功能模块：
 * 1. 用户模块 - 微信登录、用户信息管理
 * 2. 打卡记录模块 - 饮酒记录创建、查询、日历数据
 * 3. 照片上传模块 - 单张/批量照片上传
 * 4. 统计模块 - 用户统计、月度统计、酒类分布
 * 5. 成就模块 - 成就列表和进度
 * 6. 社交模块 - 朋友圈动态、点赞
 */
export default class HaveADrink {
    host: string;
    http_request: any;
    upload: any;
    constructor(conf: any);

    /**
     * 设置 token
     * 
     * @param token 登录接口获取的 token
     */
    public setToken(token: string): void;

    /**
     * 微信登录, 获取openid、unionid、token
     *
     * @param req WechatLoginReq 微信登录请求参数
     * @return WechatLoginResp 微信登录返回值
     */
    public WechatLogin(req: WechatLoginReq) : Promise<WechatLoginResp>;
    
    /**
     * 获取微信手机号
     *
     * @param req WechatGetPhoneNumberReq 获取微信手机号
     * @return WechatGetPhoneNumberResp 获取微信手机号返回值
     */
    public WechatGetPhoneNumber(req: WechatGetPhoneNumberReq) : Promise<WechatGetPhoneNumberResp>;
    
    /**
     * 刷新 token 接口
     *
     * @param req RefreshTokenReq 刷新token请求参数
     * @return RefreshTokenResp 刷新 token 返回值
     */
    public RefreshToken(req: RefreshTokenReq) : Promise<RefreshTokenResp>;
    
    /**
     * 获取成就列表
     *
     * @param req GetAchievementsReq 
     * @return GetAchievementsResp 获取成就列表响应
     */
    public GetAchievements(req: GetAchievementsReq) : Promise<GetAchievementsResp>;
    
    /**
     * 获取朋友圈动态
     *
     * @param req GetFeedReq 获取朋友圈动态请求
     * @return GetFeedResp 获取朋友圈动态响应
     */
    public GetFeed(req: GetFeedReq) : Promise<GetFeedResp>;
    
    /**
     * 上传照片
     *
     * @param req UploadPhotoReq 上传照片请求
     * @return UploadPhotoResp 上传照片响应
     */
    public UploadPhoto(req: UploadPhotoReq) : Promise<UploadPhotoResp>;
    
    /**
     * 批量上传照片
     *
     * @param req UploadPhotosReq 批量上传照片请求
     * @return UploadPhotosResp 批量上传照片响应
     */
    public UploadPhotos(req: UploadPhotosReq) : Promise<UploadPhotosResp>;
    
    /**
     * 创建打卡记录
     *
     * @param req CreateRecordReq 创建打卡记录请求
     * @return CreateRecordResp 创建打卡记录响应
     */
    public CreateRecord(req: CreateRecordReq) : Promise<CreateRecordResp>;
    
    /**
     * 获取记录列表
     *
     * @param req GetRecordsReq 获取记录列表请求
     * @return GetRecordsResp 获取记录列表响应
     */
    public GetRecords(req: GetRecordsReq) : Promise<GetRecordsResp>;
    
    /**
     * 获取单条记录详情
     *
     * @param req GetRecordDetailReq 获取单条记录详情请求
     * @return GetRecordDetailResp 获取单条记录详情响应
     */
    public GetRecordDetail(req: GetRecordDetailReq) : Promise<GetRecordDetailResp>;
    
    /**
     * 删除记录
     *
     * @param req DeleteRecordReq 删除记录请求
     * @return DeleteRecordResp 删除记录响应
     */
    public DeleteRecord(req: DeleteRecordReq) : Promise<DeleteRecordResp>;
    
    /**
     * 获取日历打卡数据
     *
     * @param req GetCalendarReq 获取日历打卡数据请求
     * @return GetCalendarResp 获取日历打卡数据响应
     */
    public GetCalendar(req: GetCalendarReq) : Promise<GetCalendarResp>;
    
    /**
     * 获取用户统计概览
     *
     * @param req GetStatsOverviewReq 
     * @return GetStatsOverviewResp 获取用户统计概览响应
     */
    public GetStatsOverview(req: GetStatsOverviewReq) : Promise<GetStatsOverviewResp>;
    
    /**
     * 获取月度统计
     *
     * @param req GetMonthlyStatsReq 获取月度统计请求
     * @return GetMonthlyStatsResp 获取月度统计响应
     */
    public GetMonthlyStats(req: GetMonthlyStatsReq) : Promise<GetMonthlyStatsResp>;
    
    /**
     * 获取酒类分布统计
     *
     * @param req GetCategoryStatsReq 
     * @return GetCategoryStatsResp 获取酒类分布统计响应
     */
    public GetCategoryStats(req: GetCategoryStatsReq) : Promise<GetCategoryStatsResp>;
    
    /**
     * 获取用户信息
     *
     * @param req GetUserProfileReq 获取用户信息请求
     * @return GetUserProfileResp 获取用户信息响应
     */
    public GetUserProfile(req: GetUserProfileReq) : Promise<GetUserProfileResp>;
    
    /**
     * 更新用户偏好
     *
     * @param req UpdatePreferencesReq 更新用户偏好请求
     * @return UpdatePreferencesResp 更新用户偏好响应
     */
    public UpdatePreferences(req: UpdatePreferencesReq) : Promise<UpdatePreferencesResp>;
    
    /**
     * 上传文件
     *
     * @param req UploadImageReq 上传图片参数
     * @return UploadImageResp 上传图片返回
     */
    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;
    
}