flutter-sport/lib/services/api/rest_client.g.dart

// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'rest_client.dart';

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

// ignore_for_file: unnecessary_brace_in_string_interps

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

  final Dio _dio;

  String? baseUrl;

  @override
  Future<RespData<UpdateInfo>> checkUpdate(version) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'version': version};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<UpdateInfo>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/app/checkUpdate',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<UpdateInfo>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Hardware>> checkHardwareUpdate(ver, appVer) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'hardware_ver': ver,
      r'app_ver': appVer
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Hardware>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/app/hardwareLastVer',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Hardware>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> onConnBt(shoes_mac, firmware_ver, hardware_ver,
      app_ver, os_name, os_ver, lang, phone_brand, phone_model) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'shoes_mac': shoes_mac,
      r'firmware_ver': firmware_ver,
      r'hardware_ver': hardware_ver,
      r'app_ver': app_ver,
      r'os_name': os_name,
      r'os_ver': os_ver,
      r'lang': lang,
      r'phone_brand': phone_brand,
      r'phone_model': phone_model
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/app/onConnBt',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> logHardwareErr(shoes_mac, firmware_ver, hardware_ver,
      app_ver, err_code, err_msg, err_detail) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'shoes_mac': shoes_mac,
      r'firmware_ver': firmware_ver,
      r'hardware_ver': hardware_ver,
      r'app_ver': app_ver,
      r'err_code': err_code,
      r'err_msg': err_msg,
      r'err_detail': err_detail
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/app/logHardwareErr',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

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

  @override
  Future<RespData<UserInfo>> getUserInfoSelf() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<UserInfo>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/info',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<UserInfo>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<int>> getCountNameCard() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<int>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/countNameCard',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<int>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportIndex>> getSportIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportIndex>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sport/index',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportIndex>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<ExerIndex>> getExerIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<ExerIndex>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/exer/index',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<ExerIndex>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportDetail>> getSportDetail() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportDetail>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sport/detail',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportDetail>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<GameAddEntity>> postAddGame(
      gameId,
      score,
      level,
      record,
      mode,
      duration,
      consume,
      screen,
      jumpCount,
      crouchCount,
      stepCount,
      distance,
      opponent_id,
      is_cancel,
      play_group,
      movements,
      time) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'game_id': gameId,
      r'score': score,
      r'level': level,
      r'record': record,
      r'mode': mode,
      r'duration': duration,
      r'consume': consume,
      r'screen': screen,
      r'jump': jumpCount,
      r'crouch': crouchCount,
      r'step': stepCount,
      r'distance': distance,
      r'opponent_id': opponent_id,
      r'is_cancel': is_cancel,
      r'play_group': play_group,
      r'movements': movements,
      r'time': time
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<GameAddEntity>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/gameRecord/addGame',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<GameAddEntity>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<SportTarget>> getSportTargetAll() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<SportTarget>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sportTarget/all',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<SportTarget>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportTargetToday>> setSportTarget(id) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportTargetToday>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sportTarget/setold',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportTargetToday>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportTargetToday>> setSportTargetToday(type,
      {consume, durationMinute}) async {
    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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportTargetToday>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sportTarget/set',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportTargetToday>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportTargetToday>> setSportTargetCustom(
      duration, consume) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'duration': duration,
      r'consume': consume
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportTargetToday>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sportTarget/setCustom',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportTargetToday>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<Resp> delSportTarget() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(_setStreamType<Resp>(
        Options(method: 'GET', headers: _headers, extra: _extra)
            .compose(_dio.options, '/sportTarget/del',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = Resp.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportTargetToday>> getSportTargetMy() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportTargetToday>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sportTarget/my',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportTargetToday>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportTargetIndex>> getSportTargetIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportTargetIndex>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sportTarget/index',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportTargetIndex>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<SportTargetRecord>> getSportTargetRecord(year, month) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year, r'month': month};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<SportTargetRecord>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/sportTarget/records',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<SportTargetRecord>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> sportTargetReward(id) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'application/x-www-form-urlencoded')
            .compose(_dio.options, '/sportTarget/reward',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportDetailSimple>> getSportRecordListOneDay(date,
      {exceptDaily}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'date': date,
      r'except_daily': exceptDaily
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportDetailSimple>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/exerRecord/listOneDay',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportDetailSimple>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportDetailSimple>> getSportRecordListByDay(begin, end,
      {exceptDaily}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'begin': begin,
      r'end': end,
      r'except_daily': exceptDaily
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportDetailSimple>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/exerRecord/listByDay',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportDetailSimple>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportDetailSimple>> getSportRecordListByMonth(year,
      {exceptDaily}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'year': year,
      r'except_daily': exceptDaily
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportDetailSimple>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/exerRecord/listByMonth',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportDetailSimple>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportDetailSimple>> getSportRecordListByYear(
      {exceptDaily}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'except_daily': exceptDaily};
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportDetailSimple>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/exerRecord/listByYear',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportDetailSimple>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<SportHistory>> getSportRecordHistory(year) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<SportHistory>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/exerRecord/history',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<SportHistory>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<RecordsTodaySum>> getSportRecordList(gameId, {page}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'game_id': gameId,
      r'page': page
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<RecordsTodaySum>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/gameRecord/list',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<RecordsTodaySum>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportStep>> 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 _headers = <String, dynamic>{};
    final _data = {'data': data};
    _data.removeWhere((k, v) => v == null);
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportStep>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'application/x-www-form-urlencoded')
            .compose(_dio.options, '/stepRecord/addDaily',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportStep>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportStep>> getStepRecordListOneDay(date) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'date': date};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportStep>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/stepRecord/listOneDay',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportStep>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportStep>> getStepRecordListByDay(begin, end) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'begin': begin, r'end': end};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportStep>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/stepRecord/listByDay',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportStep>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportStep>> getStepRecordListByMonth(year) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportStep>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/stepRecord/listByMonth',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportStep>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<SportStep>> getStepRecordListByYear() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<SportStep>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/stepRecord/listByYear',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<SportStep>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<GameRecordHistory>> getGameRecordSum() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<GameRecordHistory>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/gameRecord/sum',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<GameRecordHistory>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<GameRecord>> getGameRecord(gameId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': gameId};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<GameRecord>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/gameRecord/game',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<GameRecord>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<RankInfo>> getRankInfo(gameId,
      {provinceId, cityId, districtId, scope}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'game_id': gameId,
      r'province_id': provinceId,
      r'city_id': cityId,
      r'district_id': districtId,
      r'scope': scope
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<RankInfo>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/rank/game',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<RankInfo>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<Forum>> getForumIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<Forum>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/index',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<Forum>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<Forum>> getForumIndex2() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<Forum>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/index2',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<Forum>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Post>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<Post>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/list',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<Post>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Post>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<Post>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/listByOfficial',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<Post>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Post>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final newOptions = newRequestOptions(options);
    newOptions.extra.addAll(_extra);
    newOptions.headers.addAll(_dio.options.headers);
    newOptions.headers.addAll(_headers);
    final _result = await _dio.fetch<Map<String, dynamic>>(newOptions.copyWith(
        method: 'GET',
        baseUrl: baseUrl ?? _dio.options.baseUrl,
        queryParameters: queryParameters,
        path: '/forum/listByHot')
      ..data = _data);
    final value = RespPage<Post>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Post>> getPostListByUser(uid,
      {forumId, page, sortBy, removeTop, isOfficial}) async {
    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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<Post>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/listByUser',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<Post>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Post>> getPostListByFollow(uid,
      {forumId, page, limit, testuid, sortBy, isOfficial, options}) async {
    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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final newOptions = newRequestOptions(options);
    newOptions.extra.addAll(_extra);
    newOptions.headers.addAll(_dio.options.headers);
    newOptions.headers.addAll(_headers);
    final _result = await _dio.fetch<Map<String, dynamic>>(newOptions.copyWith(
        method: 'GET',
        baseUrl: baseUrl ?? _dio.options.baseUrl,
        queryParameters: queryParameters,
        path: '/forum/listByFollow')
      ..data = _data);
    final value = RespPage<Post>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Post>> getPostDetail(subjectId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectId': subjectId};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Post>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/subjectDetail',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Post>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Comment>> getPostComments(subjectId, {page, sortBy}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'subjectId': subjectId,
      r'p': page,
      r'sortBy': sortBy
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<Comment>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/comments',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<Comment>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Comment>> getPostCommentSubs(parentCommentId,
      {page, sortBy}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'parentCommentId': parentCommentId,
      r'p': page,
      r'sortBy': sortBy
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<Comment>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/subComments',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<Comment>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<Comment>> getPostCommentsFromId(commentId,
      {limit, sortBy}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'commentId': commentId,
      r'limit': limit,
      r'sortBy': sortBy
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<Comment>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/commentsFromId',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<Comment>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<String>> getSearchWords() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<String>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/hotSearchWords',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> postForumLike(objectId, fieldName) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'objectId': objectId,
      r'fieldName': fieldName
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/like',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> postForumUnLike(objectId, fieldName) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'objectId': objectId,
      r'fieldName': fieldName
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/unlike',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> postDelSubject(subjectId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectId': subjectId};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/delSubject',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> postDelComment(commentId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'commentId': commentId};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/delComment',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/report',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<int>> postForumBlockUser(uid) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<int>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/blockUser',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<int>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<int>> postForumUnBlockUser(uid) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<int>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/unblockUser',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<int>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<UserInfo>> getMyBlockUsers() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<UserInfo>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/myBlockUsers',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<UserInfo>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> postForumBlockObject(objectId, forName) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'objectId': objectId,
      r'for': forName
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/blockObject',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<CommentPost>> postForumComment(subjectId, content,
      {parentCommentId, toCommentId}) async {
    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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<CommentPost>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/postComment',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<CommentPost>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Map<String, dynamic>>> postForum(forumId, content,
      {images, quoteSubjectId, quoteCommentId, quoteData, cancelToken}) async {
    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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Map<String, dynamic>>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/post',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Map<String, dynamic>>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> setUserTopSubjects(subjectIdList) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectIdList': subjectIdList};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/setUserTopSubjects',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> unsetUserTopSubjects(subjectIdList) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'subjectIdList': subjectIdList};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/unsetUserTopSubjects',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<Post>> getPostUserTopSubjects(uid,
      {forumId, page, sortBy}) async {
    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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<Post>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/userTopSubjects',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<Post>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/follow',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> userUnFollow({uid}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/unfollow',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<bool>> userIgnoreFollow({uid}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<bool>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/ignoreFollow',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<bool>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<FriendRelation>> userRelation({uid}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<FriendRelation>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/UserRelation',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<FriendRelation>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<FriendList>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<FriendList>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/followList',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<FriendList>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<FriendList>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<FriendList>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/fansList',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<FriendList>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<UserFriend>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<UserFriend>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/friends',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<UserFriend>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<FriendList>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<FriendList>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/forum/friends',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<FriendList>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<UserInfo>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<UserInfo>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/search',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<UserInfo>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<dynamic>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<dynamic>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/newFriendCode',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<dynamic>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<NewFriend>> getNewFriend(code) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'code': code};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<NewFriend>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/newFriend',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<NewFriend>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<MessageInstance>> shareForwardSubject(
      subjectId, userId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'subject_id': subjectId,
      r'user_id': userId
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<MessageInstance>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/share/forwardSubject',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<MessageInstance>.fromJson(_result.data!);
    return value;
  }

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

  @override
  Future<RespList<UserFriend>> getFriendRequest() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<UserFriend>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/FetchFriendsRequest',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<UserFriend>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<bool>> postRejectFriend(uid) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<bool>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/RejectFriend',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<bool>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<dynamic>> postAcceptFriend(uid) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<dynamic>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/AcceptFriend',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<dynamic>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<bool>> postIsFriend(uid) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'uid': uid};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<bool>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/user/isFriend',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<bool>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<ChatMessageInstance>> getChatIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<ChatMessageInstance>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/chat/index',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<ChatMessageInstance>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<ChatMessage>> getChatUser(userId, {beginId}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'user_id': userId,
      r'begin_id': beginId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<ChatMessage>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/chat/user',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<ChatMessage>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<MessageInstance>> postChatSend(userId, type, data) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'user_id': userId,
      r'type': type,
      r'data': data
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<MessageInstance>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/chat/send',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<MessageInstance>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<dynamic>> postChatUpload(file) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{r'content-type': 'multipart/form-data'};
    _headers.removeWhere((k, v) => v == null);
    final _data = FormData();
    _data.files.add(MapEntry(
        'file',
        MultipartFile.fromFileSync(file.path,
            filename: file.path.split(Platform.pathSeparator).last)));
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<dynamic>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'multipart/form-data')
            .compose(_dio.options, '/chat/upload',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<dynamic>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<ChatOnlineInfo>> getChatUserInfo(userIds) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = {'user_ids': userIds};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<ChatOnlineInfo>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'application/x-www-form-urlencoded')
            .compose(_dio.options, '/chat/info',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<ChatOnlineInfo>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<ShareInfo>> getshareCreateSport(period, weight) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'period': period,
      r'weight': weight
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<ShareInfo>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/share/createSport',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<ShareInfo>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<MessageInstance>> getshareForwardSport(hash, userId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'h': hash, r'user_id': userId};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<MessageInstance>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/share/forwardSport',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<MessageInstance>.fromJson(_result.data!);
    return value;
  }

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

  @override
  Future<RespData<dynamic>> postInformRead(informId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'informId': informId};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<dynamic>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/inform/read',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<dynamic>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespPage<Notice>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespPage<Notice>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/notice/list',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespPage<Notice>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<int>> getNoticeCount(type, read, {isMsg = "1"}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'type': type,
      r'read': read,
      r'isMsg': isMsg
    };
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<int>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/notice/count',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<int>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Notice>> postNoticeRead(noticeId) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'noticeId': noticeId};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Notice>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/notice/read',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Notice>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<FeedbackCategory>> getFeedbackTypes() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<FeedbackCategory>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/feedback/types',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<FeedbackCategory>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<FeedbackCategory>> 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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<FeedbackCategory>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/feedback/myChats',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<FeedbackCategory>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> postFeedback(typeId, content,
      {images, extra}) async {
    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 _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/feedback/post',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> mediaUp4Feedback(file) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{r'content-type': 'multipart/form-data'};
    _headers.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 _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'multipart/form-data')
            .compose(_dio.options, '/media/Up4Feedback',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Image>> mediaUp4Subject(file,
      {srcType, subjectId, cancelToken}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{
      r'srcType': srcType,
      r'subjectId': subjectId
    };
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{r'content-type': 'multipart/form-data'};
    _headers.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 _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Image>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'multipart/form-data')
            .compose(_dio.options, '/media/Up4Subject',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Image>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespList<GameInfoData>> getGameAll() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<GameInfoData>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/game/all',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<GameInfoData>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<dynamic> getGameById(id) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch(_setStreamType<dynamic>(
        Options(method: 'GET', headers: _headers, extra: _extra)
            .compose(_dio.options, '/game/all',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = _result.data;
    return value;
  }

  @override
  Future<RespList<RankInfoData>> getRankInfoAll() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespList<RankInfoData>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/rank/all',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespList<RankInfoData>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<RankGameInfoData>> getRankGameInfo(id, {scope}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'game_id': id, r'scope': scope};
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<RankGameInfoData>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/rank/game',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<RankGameInfoData>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<RankGameInfoData>> getRankSportInfo(id, {scope}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'rank_id': id, r'scope': scope};
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<RankGameInfoData>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/rank/sport',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<RankGameInfoData>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<ShopIndex>> getShopIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<ShopIndex>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/shop/item',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<ShopIndex>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<ScoreList>> getScoreIndex() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<ScoreList>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/score/record',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<ScoreList>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Map<String, dynamic>>> buyItem(id) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'item_id': id};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Map<String, dynamic>>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/shop/buy',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Map<String, dynamic>>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Map<String, dynamic>>> jogAddRecord(
      begin,
      end,
      distance,
      step,
      consume,
      track,
      stepInfo,
      altitudeInfo,
      kmDurationInfo,
      thumb,
      media) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{r'content-type': 'multipart/form-data'};
    _headers.removeWhere((k, v) => v == null);
    final _data = FormData();
    _data.fields.add(MapEntry('begin', begin.toString()));
    _data.fields.add(MapEntry('end', end.toString()));
    _data.fields.add(MapEntry('distance', distance.toString()));
    _data.fields.add(MapEntry('step', step.toString()));
    _data.fields.add(MapEntry('consume', consume.toString()));
    _data.fields.add(MapEntry('track', track));
    _data.fields.add(MapEntry('step_info', stepInfo));
    _data.fields.add(MapEntry('altitude_info', altitudeInfo));
    _data.fields.add(MapEntry('km_duration_info', kmDurationInfo));
    _data.fields.add(MapEntry('track_thumb', thumb));
    _data.files.add(MapEntry(
        'media',
        MultipartFile.fromFileSync(media.path,
            filename: media.path.split(Platform.pathSeparator).last)));
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Map<String, dynamic>>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'multipart/form-data')
            .compose(_dio.options, '/jog/addRecord',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Map<String, dynamic>>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> jogDelRecord(id) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/jog/delRecord',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<String>> jogCopyRecord(id) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<String>>(
            Options(method: 'POST', headers: _headers, extra: _extra)
                .compose(_dio.options, '/jog/copyRecord',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<String>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<JogDetail>> jogShowRecord(id) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'id': id};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<JogDetail>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/jog/show',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<JogDetail>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<JogSum>> jogListOneYear(year) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<JogSum>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/jog/listOneYear',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<JogSum>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<JogRecord>> jogListByDay(begin, end) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'begin': begin, r'end': end};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<JogRecord>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/jog/listByDay',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<JogRecord>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<JogRecord>> jogListByMonth(year) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{r'year': year};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<JogRecord>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/jog/listByMonth',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<JogRecord>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<JogRecord>> jogListByYear() async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    final _headers = <String, dynamic>{};
    final _data = <String, dynamic>{};
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<JogRecord>>(
            Options(method: 'GET', headers: _headers, extra: _extra)
                .compose(_dio.options, '/jog/listByYear',
                    queryParameters: queryParameters, data: _data)
                .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<JogRecord>.fromJson(_result.data!);
    return value;
  }

  @override
  Future<RespData<Map<String, dynamic>>> jogSetting({setting}) async {
    const _extra = <String, dynamic>{};
    final queryParameters = <String, dynamic>{};
    queryParameters.removeWhere((k, v) => v == null);
    final _headers = <String, dynamic>{};
    final _data = {'setting': setting};
    _data.removeWhere((k, v) => v == null);
    final _result = await _dio.fetch<Map<String, dynamic>>(
        _setStreamType<RespData<Map<String, dynamic>>>(Options(
                method: 'POST',
                headers: _headers,
                extra: _extra,
                contentType: 'application/x-www-form-urlencoded')
            .compose(_dio.options, '/jog/setting',
                queryParameters: queryParameters, data: _data)
            .copyWith(baseUrl: baseUrl ?? _dio.options.baseUrl)));
    final value = RespData<Map<String, dynamic>>.fromJson(_result.data!);
    return value;
  }

  RequestOptions newRequestOptions(Object? options) {
    if (options is RequestOptions) {
      return options as RequestOptions;
    }
    if (options is Options) {
      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,
        path: '',
      );
    }
    return RequestOptions(path: '');
  }

  RequestOptions _setStreamType<T>(RequestOptions requestOptions) {
    if (T != dynamic &&
        !(requestOptions.responseType == ResponseType.bytes ||
            requestOptions.responseType == ResponseType.stream)) {
      if (T == String) {
        requestOptions.responseType = ResponseType.plain;
      } else {
        requestOptions.responseType = ResponseType.json;
      }
    }
    return requestOptions;
  }
}