// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'rest_client.dart';

// **************************************************************************
// RetrofitGenerator
// **************************************************************************

class _RestClient implements RestClient {
  _RestClient(this._dio, {this.baseUrl}) {
    ArgumentError.checkNotNull(_dio, '_dio');
  }

  final Dio _dio;

  String baseUrl;

  @override
  checkUpdate(version) async {
    ArgumentError.checkNotNull(version, 'version');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'version': version};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/app/checkUpdate',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<UpdateInfo>.fromJson(_result.data);
    return value;
  }

  @override
  getUserInfo(uid, {options}) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': uid};
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final newOptions = newRequestOptions(options);
    newOptions.extra.addAll(_extra);
    newOptions.headers.addAll(<String, dynamic>{});
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/info',
        queryParameters: queryParameters,
        options: newOptions.merge(method: 'GET', baseUrl: baseUrl),
        data: _data);
    final value = RespData<UserInfo>.fromJson(_result.data);
    return value;
  }

  @override
  getCountNameCard() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/countNameCard',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<int>.fromJson(_result.data);
    return value;
  }

  @override
  getSportIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sport/index',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportIndex>.fromJson(_result.data);
    return value;
  }

  @override
  getSportDetail() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sport/detail',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportDetail>.fromJson(_result.data);
    return value;
  }

  @override
  postAddGame(gameId, score, duration, consume, screen, jumpCount, crouchCount,
      stepCount, distance) async {
    ArgumentError.checkNotNull(gameId, 'gameId');
    ArgumentError.checkNotNull(score, 'score');
    ArgumentError.checkNotNull(duration, 'duration');
    ArgumentError.checkNotNull(consume, 'consume');
    ArgumentError.checkNotNull(screen, 'screen');
    ArgumentError.checkNotNull(jumpCount, 'jumpCount');
    ArgumentError.checkNotNull(crouchCount, 'crouchCount');
    ArgumentError.checkNotNull(stepCount, 'stepCount');
    ArgumentError.checkNotNull(distance, 'distance');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'game_id': gameId,
      r'score': score,
      r'duration': duration,
      r'consume': consume,
      r'screen': screen,
      r'jump_count': jumpCount,
      r'crouch_count': crouchCount,
      r'step_count': stepCount,
      r'distance': distance
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportRecord/addGame',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<SportTarget>.fromJson(_result.data);
    return value;
  }

  @override
  getSportTargetAll() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/all',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<SportTarget>.fromJson(_result.data);
    return value;
  }

  @override
  setSportTarget(id) async {
    ArgumentError.checkNotNull(id, 'id');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/setold',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportTargetToday>.fromJson(_result.data);
    return value;
  }

  @override
  setSportTargetToday(type, {consume, durationMinute}) async {
    ArgumentError.checkNotNull(type, 'type');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'type': type,
      r'consume': consume,
      r'duration_minute': durationMinute
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/set',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportTargetToday>.fromJson(_result.data);
    return value;
  }

  @override
  setSportTargetCustom(duration, consume) async {
    ArgumentError.checkNotNull(duration, 'duration');
    ArgumentError.checkNotNull(consume, 'consume');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'duration': duration,
      r'consume': consume
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/setCustom',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportTargetToday>.fromJson(_result.data);
    return value;
  }

  @override
  delSportTarget() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/del',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = Resp.fromJson(_result.data);
    return value;
  }

  @override
  getSportTargetMy() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/my',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportTargetToday>.fromJson(_result.data);
    return value;
  }

  @override
  getSportTargetIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/index',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportTargetIndex>.fromJson(_result.data);
    return value;
  }

  @override
  getSportTargetRecord(year, month) async {
    ArgumentError.checkNotNull(year, 'year');
    ArgumentError.checkNotNull(month, 'month');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year, r'month': month};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/records',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<SportTargetRecord>.fromJson(_result.data);
    return value;
  }

  @override
  sportTargetReward(id) async {
    ArgumentError.checkNotNull(id, 'id');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportTarget/reward',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            contentType: 'application/x-www-form-urlencoded',
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  getSportRecordListOneDay(date) async {
    ArgumentError.checkNotNull(date, 'date');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'date': date};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportRecord/listOneDay',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportDetailSimple>.fromJson(_result.data);
    return value;
  }

  @override
  getSportRecordListByDay(begin, end) async {
    ArgumentError.checkNotNull(begin, 'begin');
    ArgumentError.checkNotNull(end, 'end');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'begin': begin, r'end': end};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportRecord/listByDay',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportDetailSimple>.fromJson(_result.data);
    return value;
  }

  @override
  getSportRecordListByMonth(year) async {
    ArgumentError.checkNotNull(year, 'year');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportRecord/listByMonth',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportDetailSimple>.fromJson(_result.data);
    return value;
  }

  @override
  getSportRecordListByYear() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportRecord/listByYear',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportDetailSimple>.fromJson(_result.data);
    return value;
  }

  @override
  getSportRecordList(gameId, {page}) async {
    ArgumentError.checkNotNull(gameId, 'gameId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'game_id': gameId,
      r'page': page
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/sportRecord/list',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<RecordsTodaySum>.fromJson(_result.data);
    return value;
  }

  @override
  addDaily({step, distance, time, data}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'step': step,
      r'distance': distance,
      r'time': time
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = {'data': data};
    _data.removeWhere((k, v) => v == null);
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/stepRecord/addDaily',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            contentType: 'application/x-www-form-urlencoded',
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportStep>.fromJson(_result.data);
    return value;
  }

  @override
  getStepRecordListOneDay(date) async {
    ArgumentError.checkNotNull(date, 'date');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'date': date};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/stepRecord/listOneDay',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportStep>.fromJson(_result.data);
    return value;
  }

  @override
  getStepRecordListByDay(begin, end) async {
    ArgumentError.checkNotNull(begin, 'begin');
    ArgumentError.checkNotNull(end, 'end');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'begin': begin, r'end': end};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/stepRecord/listByDay',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportStep>.fromJson(_result.data);
    return value;
  }

  @override
  getStepRecordListByMonth(year) async {
    ArgumentError.checkNotNull(year, 'year');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/stepRecord/listByMonth',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportStep>.fromJson(_result.data);
    return value;
  }

  @override
  getStepRecordListByYear() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/stepRecord/listByYear',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<SportStep>.fromJson(_result.data);
    return value;
  }

  @override
  getGameRecordSum() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/gameRecord/sum',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<GameRecordSum>.fromJson(_result.data);
    return value;
  }

  @override
  getGameRecord(gameId) async {
    ArgumentError.checkNotNull(gameId, 'gameId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': gameId};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/gameRecord/game',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<GameRecord>.fromJson(_result.data);
    return value;
  }

  @override
  getRankInfo(gameId, {provinceId, cityId, districtId}) async {
    ArgumentError.checkNotNull(gameId, 'gameId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'game_id': gameId,
      r'province_id': provinceId,
      r'city_id': cityId,
      r'district_id': districtId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/rank/game',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<RankInfo>.fromJson(_result.data);
    return value;
  }

  @override
  getForumIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/index',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<Forum>.fromJson(_result.data);
    return value;
  }

  @override
  getPostList({forumId, page, isGood, kw, isOfficial}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'forumId': forumId,
      r'p': page,
      r'isGood': isGood,
      r'kw': kw,
      r'isOfficial': isOfficial
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/list',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Post>.fromJson(_result.data);
    return value;
  }

  @override
  getPostListByOfficial({forumId, page, limit, sortBy, isOfficial}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'forumId': forumId,
      r'p': page,
      r'limit': limit,
      r'sortBy': sortBy,
      r'isOfficial': isOfficial
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/listByOfficial',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Post>.fromJson(_result.data);
    return value;
  }

  @override
  getPostListByHot({forumId, page, isOfficial, options}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'forumId': forumId,
      r'p': page,
      r'isOfficial': isOfficial
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final newOptions = newRequestOptions(options);
    newOptions.extra.addAll(_extra);
    newOptions.headers.addAll(<String, dynamic>{});
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/listByHot',
        queryParameters: queryParameters,
        options: newOptions.merge(method: 'GET', baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Post>.fromJson(_result.data);
    return value;
  }

  @override
  getPostListByUser(uid, {forumId, page, sortBy, removeTop, isOfficial}) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'uid': uid,
      r'forumId': forumId,
      r'p': page,
      r'sortBy': sortBy,
      r'removeTop': removeTop,
      r'isOfficial': isOfficial
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/listByUser',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Post>.fromJson(_result.data);
    return value;
  }

  @override
  getPostListByFollow(uid,
      {forumId, page, limit, testuid, sortBy, isOfficial, options}) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'uid': uid,
      r'forumId': forumId,
      r'p': page,
      r'limit': limit,
      r'testuid': testuid,
      r'sortBy': sortBy,
      r'isOfficial': isOfficial
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final newOptions = newRequestOptions(options);
    newOptions.extra.addAll(_extra);
    newOptions.headers.addAll(<String, dynamic>{});
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/listByFollow',
        queryParameters: queryParameters,
        options: newOptions.merge(method: 'GET', baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Post>.fromJson(_result.data);
    return value;
  }

  @override
  getPostDetail(subjectId) async {
    ArgumentError.checkNotNull(subjectId, 'subjectId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectId': subjectId};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/subjectDetail',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<Post>.fromJson(_result.data);
    return value;
  }

  @override
  getPostComments(subjectId, {page, sortBy}) async {
    ArgumentError.checkNotNull(subjectId, 'subjectId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'subjectId': subjectId,
      r'p': page,
      r'sortBy': sortBy
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/comments',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Comment>.fromJson(_result.data);
    return value;
  }

  @override
  getPostCommentSubs(parentCommentId, {page, sortBy}) async {
    ArgumentError.checkNotNull(parentCommentId, 'parentCommentId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'parentCommentId': parentCommentId,
      r'p': page,
      r'sortBy': sortBy
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/subComments',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Comment>.fromJson(_result.data);
    return value;
  }

  @override
  getPostCommentsFromId(commentId, {limit, sortBy}) async {
    ArgumentError.checkNotNull(commentId, 'commentId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'commentId': commentId,
      r'limit': limit,
      r'sortBy': sortBy
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/commentsFromId',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<Comment>.fromJson(_result.data);
    return value;
  }

  @override
  getSearchWords() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/hotSearchWords',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<String>.fromJson(_result.data);
    return value;
  }

  @override
  postForumLike(objectId, fieldName) async {
    ArgumentError.checkNotNull(objectId, 'objectId');
    ArgumentError.checkNotNull(fieldName, 'fieldName');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'objectId': objectId,
      r'fieldName': fieldName
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/like',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  postForumUnLike(objectId, fieldName) async {
    ArgumentError.checkNotNull(objectId, 'objectId');
    ArgumentError.checkNotNull(fieldName, 'fieldName');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'objectId': objectId,
      r'fieldName': fieldName
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/unlike',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  postDelSubject(subjectId) async {
    ArgumentError.checkNotNull(subjectId, 'subjectId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectId': subjectId};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/delSubject',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  postDelComment(commentId) async {
    ArgumentError.checkNotNull(commentId, 'commentId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'commentId': commentId};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/delComment',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  postForumReport({subjectId, commentId, content, userId}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'subjectId': subjectId,
      r'commentId': commentId,
      r'content': content,
      r'userId': userId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/report',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  postForumBlockUser(uid) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/blockUser',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<int>.fromJson(_result.data);
    return value;
  }

  @override
  postForumUnBlockUser(uid) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/unblockUser',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<int>.fromJson(_result.data);
    return value;
  }

  @override
  getMyBlockUsers() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/myBlockUsers',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<UserInfo>.fromJson(_result.data);
    return value;
  }

  @override
  postForumBlockObject(objectId, forName) async {
    ArgumentError.checkNotNull(objectId, 'objectId');
    ArgumentError.checkNotNull(forName, 'forName');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'objectId': objectId,
      r'for': forName
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/blockObject',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  postForumComment(subjectId, content, {parentCommentId, toCommentId}) async {
    ArgumentError.checkNotNull(subjectId, 'subjectId');
    ArgumentError.checkNotNull(content, 'content');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'subjectId': subjectId,
      r'content': content,
      r'parentCommentId': parentCommentId,
      r'toCommentId': toCommentId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/postComment',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<CommentPost>.fromJson(_result.data);
    return value;
  }

  @override
  postForum(forumId, content,
      {images, quoteSubjectId, quoteCommentId, quoteData, cancelToken}) async {
    ArgumentError.checkNotNull(forumId, 'forumId');
    ArgumentError.checkNotNull(content, 'content');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'forumId': forumId,
      r'content': content,
      r'images': images,
      r'quoteSubjectId': quoteSubjectId,
      r'quoteCommentId': quoteCommentId,
      r'quoteData': quoteData
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/post',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<Map<String, dynamic>>.fromJson(_result.data);
    return value;
  }

  @override
  setUserTopSubjects(subjectIdList) async {
    ArgumentError.checkNotNull(subjectIdList, 'subjectIdList');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectIdList': subjectIdList};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/setUserTopSubjects',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  unsetUserTopSubjects(subjectIdList) async {
    ArgumentError.checkNotNull(subjectIdList, 'subjectIdList');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectIdList': subjectIdList};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/unsetUserTopSubjects',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  getPostUserTopSubjects(uid, {forumId, page, sortBy}) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'uid': uid,
      r'forumId': forumId,
      r'p': page,
      r'sortBy': sortBy
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/userTopSubjects',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<Post>.fromJson(_result.data);
    return value;
  }

  @override
  userFollow({uid, groupId, groupName}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'uid': uid,
      r'groupId': groupId,
      r'groupName': groupName
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/follow',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  userUnFollow({uid}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/unfollow',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  userIgnoreFollow({uid}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/ignoreFollow',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  userFollowList({groupId, kw, page, limit = 50}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'groupId': groupId,
      r'kw': kw,
      r'p': page,
      r'limit': limit
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/followList',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespListTest<UserFriend>.fromJson(_result.data);
    return value;
  }

  @override
  userFansList({groupId, kw, page, limit = 50}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'groupId': groupId,
      r'kw': kw,
      r'p': page,
      r'limit': limit
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/fansList',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespListTest<UserFriend>.fromJson(_result.data);
    return value;
  }

  @override
  userFriends({groupId, kw, page, limit = 50, test}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'groupId': groupId,
      r'kw': kw,
      r'p': page,
      r'limit': limit,
      r'test': test
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/friends',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<UserFriend>.fromJson(_result.data);
    return value;
  }

  @override
  userFriendsTest({groupId, kw, page, limit = 50, test}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'groupId': groupId,
      r'kw': kw,
      r'p': page,
      r'limit': limit,
      r'test': test
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/forum/friends',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespListTest<UserFriend>.fromJson(_result.data);
    return value;
  }

  @override
  userSearch({kw, page, limit = 20}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'kw': kw,
      r'p': page,
      r'limit': limit
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/search',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<UserInfo>.fromJson(_result.data);
    return value;
  }

  @override
  getNewFriendCode({forever, forceUpdate}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'forever': forever,
      r'forceUpate': forceUpdate
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/newFriendCode',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<dynamic>.fromJson(_result.data);
    return value;
  }

  @override
  getNewFriend(code) async {
    ArgumentError.checkNotNull(code, 'code');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'code': code};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/newFriend',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<NewFriend>.fromJson(_result.data);
    return value;
  }

  @override
  shareForwardSubject(subjectId, userId) async {
    ArgumentError.checkNotNull(subjectId, 'subjectId');
    ArgumentError.checkNotNull(userId, 'userId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'subject_id': subjectId,
      r'user_id': userId
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/share/forwardSubject',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<MessageInstance>.fromJson(_result.data);
    return value;
  }

  @override
  getMessageForPoll({curId}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'cur_id': curId};
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/message/receive',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<Message>.fromJson(_result.data);
    return value;
  }

  @override
  getFriendRequest() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/FetchFriendsRequest',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<UserFriend>.fromJson(_result.data);
    return value;
  }

  @override
  postRejectFriend(uid) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/RejectFriend',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<bool>.fromJson(_result.data);
    return value;
  }

  @override
  postAcceptFriend(uid) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/AcceptFriend',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<dynamic>.fromJson(_result.data);
    return value;
  }

  @override
  postIsFriend(uid) async {
    ArgumentError.checkNotNull(uid, 'uid');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/user/isFriend',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<bool>.fromJson(_result.data);
    return value;
  }

  @override
  getChatIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/chat/index',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<ChatMessageInstance>.fromJson(_result.data);
    return value;
  }

  @override
  getChatUser(userId, {beginId}) async {
    ArgumentError.checkNotNull(userId, 'userId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'user_id': userId,
      r'begin_id': beginId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/chat/user',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<ChatMessage>.fromJson(_result.data);
    return value;
  }

  @override
  postChatSend(userId, type, data) async {
    ArgumentError.checkNotNull(userId, 'userId');
    ArgumentError.checkNotNull(type, 'type');
    ArgumentError.checkNotNull(data, 'data');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'user_id': userId,
      r'type': type,
      r'data': data
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/chat/send',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<MessageInstance>.fromJson(_result.data);
    return value;
  }

  @override
  postChatUpload(file) async {
    ArgumentError.checkNotNull(file, 'file');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = FormData();
    _data.files.add(MapEntry(
        'file',
        MultipartFile.fromFileSync(file.path,
            filename: file.path.split(Platform.pathSeparator).last)));
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/chat/upload',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{r'content-type': 'multipart/form-data'},
            extra: _extra,
            contentType: 'multipart/form-data',
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<dynamic>.fromJson(_result.data);
    return value;
  }

  @override
  getChatUserInfo(userIds) async {
    ArgumentError.checkNotNull(userIds, 'userIds');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'user_ids': userIds};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/chat/info',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<ChatOnlineInfo>.fromJson(_result.data);
    return value;
  }

  @override
  getshareCreateSport(period, weight) async {
    ArgumentError.checkNotNull(period, 'period');
    ArgumentError.checkNotNull(weight, 'weight');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'period': period,
      r'weight': weight
    };
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/share/createSport',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<ShareInfo>.fromJson(_result.data);
    return value;
  }

  @override
  getshareForwardSport(hash, userId) async {
    ArgumentError.checkNotNull(hash, 'hash');
    ArgumentError.checkNotNull(userId, 'userId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'h': hash, r'user_id': userId};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/share/forwardSport',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<MessageInstance>.fromJson(_result.data);
    return value;
  }

  @override
  getInformList({page}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'p': page};
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/inform/list',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Notice>.fromJson(_result.data);
    return value;
  }

  @override
  postInformRead(informId) async {
    ArgumentError.checkNotNull(informId, 'informId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'informId': informId};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/inform/read',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<dynamic>.fromJson(_result.data);
    return value;
  }

  @override
  getNoticeList({type, markread = "currpage", page, read, isMsg = "1"}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'type': type,
      r'markread': markread,
      r'p': page,
      r'read': read,
      r'isMsg': isMsg
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/notice/list',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespPage<Notice>.fromJson(_result.data);
    return value;
  }

  @override
  getNoticeCount(type, read, {isMsg = "1"}) async {
    ArgumentError.checkNotNull(type, 'type');
    ArgumentError.checkNotNull(read, 'read');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'type': type,
      r'read': read,
      r'isMsg': isMsg
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/notice/count',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<int>.fromJson(_result.data);
    return value;
  }

  @override
  postNoticeRead(noticeId) async {
    ArgumentError.checkNotNull(noticeId, 'noticeId');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'noticeId': noticeId};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/notice/read',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<Notice>.fromJson(_result.data);
    return value;
  }

  @override
  getFeedbackTypes() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/feedback/types',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<FeedbackCategory>.fromJson(_result.data);
    return value;
  }

  @override
  getFeedbackChat({groupId, typeId}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'groupId': groupId,
      r'typeId': typeId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/feedback/myChats',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<FeedbackCategory>.fromJson(_result.data);
    return value;
  }

  @override
  postFeedback(typeId, content, {images, extra}) async {
    ArgumentError.checkNotNull(typeId, 'typeId');
    ArgumentError.checkNotNull(content, 'content');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'typeId': typeId,
      r'content': content,
      r'images': images,
      r'extra': extra
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/feedback/post',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  mediaUp4Feedback(file) async {
    ArgumentError.checkNotNull(file, 'file');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = FormData();
    _data.files.add(MapEntry(
        'media',
        MultipartFile.fromFileSync(file.path,
            filename: file.path.split(Platform.pathSeparator).last)));
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/media/Up4Feedback',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{r'content-type': 'multipart/form-data'},
            extra: _extra,
            contentType: 'multipart/form-data',
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  @override
  mediaUp4Subject(file, {srcType, subjectId, cancelToken}) async {
    ArgumentError.checkNotNull(file, 'file');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'srcType': srcType,
      r'subjectId': subjectId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _data = FormData();
    _data.files.add(MapEntry(
        'media',
        MultipartFile.fromFileSync(file.path,
            filename: file.path.split(Platform.pathSeparator).last)));
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/media/Up4Subject',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{r'content-type': 'multipart/form-data'},
            extra: _extra,
            contentType: 'multipart/form-data',
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<Image>.fromJson(_result.data);
    return value;
  }

  @override
  getGameAll() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/game/all',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<GameInfoData>.fromJson(_result.data);
    return value;
  }

  @override
  getGameById(id) async {
    ArgumentError.checkNotNull(id, 'id');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _data = <String, dynamic>{};
    final Response _result = await _dio.request('/game/all',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = _result.data;
    return value;
  }

  @override
  getRankInfoAll() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/rank/all',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespList<RankInfoData>.fromJson(_result.data);
    return value;
  }

  @override
  getRankGameInfo(id, {scope}) async {
    ArgumentError.checkNotNull(id, 'id');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'game_id': id, r'scope': scope};
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/rank/game',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<RankGameInfoData>.fromJson(_result.data);
    return value;
  }

  @override
  getRankSportInfo(id, {scope}) async {
    ArgumentError.checkNotNull(id, 'id');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'rank_id': id, r'scope': scope};
    queryParameters.removeWhere((k, v) => v == null);
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/rank/sport',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<RankGameInfoData>.fromJson(_result.data);
    return value;
  }

  @override
  getShopIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/shop/item',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<ShopIndex>.fromJson(_result.data);
    return value;
  }

  @override
  getScoreIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/score/record',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'GET',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<ScoreList>.fromJson(_result.data);
    return value;
  }

  @override
  buyItem(id) async {
    ArgumentError.checkNotNull(id, 'id');
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'item_id': id};
    final _data = <String, dynamic>{};
    final Response<Map<String, dynamic>> _result = await _dio.request(
        '/shop/buy',
        queryParameters: queryParameters,
        options: RequestOptions(
            method: 'POST',
            headers: <String, dynamic>{},
            extra: _extra,
            baseUrl: baseUrl),
        data: _data);
    final value = RespData<String>.fromJson(_result.data);
    return value;
  }

  RequestOptions newRequestOptions(Options options) {
    if (options is RequestOptions) {
      return options;
    }
    if (options == null) {
      return RequestOptions();
    }
    return RequestOptions(
      method: options.method,
      sendTimeout: options.sendTimeout,
      receiveTimeout: options.receiveTimeout,
      extra: options.extra,
      headers: options.headers,
      responseType: options.responseType,
      contentType: options.contentType.toString(),
      validateStatus: options.validateStatus,
      receiveDataWhenStatusError: options.receiveDataWhenStatusError,
      followRedirects: options.followRedirects,
      maxRedirects: options.maxRedirects,
      requestEncoder: options.requestEncoder,
      responseDecoder: options.responseDecoder,
    );
  }
}