"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createRpcQueryExtension = exports.QueryClientImpl = void 0;
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _binary = require("../binary");
var _stargate = require("@cosmjs/stargate");
var _query = require("./query");
/** Query defines the gRPC querier service. */
var QueryClientImpl = exports.QueryClientImpl = /*#__PURE__*/function () {
  function QueryClientImpl(rpc) {
    (0, _classCallCheck2["default"])(this, QueryClientImpl);
    (0, _defineProperty2["default"])(this, "rpc", void 0);
    this.rpc = rpc;
    this.params = this.params.bind(this);
    this.vestedAmount = this.vestedAmount.bind(this);
    this.task = this.task.bind(this);
    this.taskAll = this.taskAll.bind(this);
    this.branchAll = this.branchAll.bind(this);
    this.repositoryBranch = this.repositoryBranch.bind(this);
    this.repositoryBranchSha = this.repositoryBranchSha.bind(this);
    this.repositoryBranchAll = this.repositoryBranchAll.bind(this);
    this.tagAll = this.tagAll.bind(this);
    this.repositoryTag = this.repositoryTag.bind(this);
    this.repositoryTagSha = this.repositoryTagSha.bind(this);
    this.repositoryTagAll = this.repositoryTagAll.bind(this);
    this.daoMember = this.daoMember.bind(this);
    this.daoMemberAll = this.daoMemberAll.bind(this);
    this.memberAll = this.memberAll.bind(this);
    this.bounty = this.bounty.bind(this);
    this.bountyAll = this.bountyAll.bind(this);
    this.release = this.release.bind(this);
    this.releaseAll = this.releaseAll.bind(this);
    this.pullRequestAll = this.pullRequestAll.bind(this);
    this.dao = this.dao.bind(this);
    this.daoAll = this.daoAll.bind(this);
    this.issueComment = this.issueComment.bind(this);
    this.pullRequestComment = this.pullRequestComment.bind(this);
    this.commentAll = this.commentAll.bind(this);
    this.issueCommentAll = this.issueCommentAll.bind(this);
    this.pullRequestCommentAll = this.pullRequestCommentAll.bind(this);
    this.issueAll = this.issueAll.bind(this);
    this.repositoryReleaseLatest = this.repositoryReleaseLatest.bind(this);
    this.repositoryRelease = this.repositoryRelease.bind(this);
    this.repositoryReleaseAll = this.repositoryReleaseAll.bind(this);
    this.repositoryIssue = this.repositoryIssue.bind(this);
    this.repositoryIssueAll = this.repositoryIssueAll.bind(this);
    this.repositoryPullRequest = this.repositoryPullRequest.bind(this);
    this.repositoryPullRequestAll = this.repositoryPullRequestAll.bind(this);
    this.repository = this.repository.bind(this);
    this.repositoryAll = this.repositoryAll.bind(this);
    this.forkAll = this.forkAll.bind(this);
    this.user = this.user.bind(this);
    this.userDaoAll = this.userDaoAll.bind(this);
    this.userAll = this.userAll.bind(this);
    this.anyRepositoryAll = this.anyRepositoryAll.bind(this);
    this.anyRepository = this.anyRepository.bind(this);
    this.whois = this.whois.bind(this);
    this.whoisAll = this.whoisAll.bind(this);
    this.pullRequestMergePermission = this.pullRequestMergePermission.bind(this);
    this.checkGitServerAuthorization = this.checkGitServerAuthorization.bind(this);
    this.checkStorageProviderAuthorization = this.checkStorageProviderAuthorization.bind(this);
  }
  return (0, _createClass2["default"])(QueryClientImpl, [{
    key: "params",
    value: function params() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
      var data = _query.QueryParamsRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "Params", data);
      return promise.then(function (data) {
        return _query.QueryParamsResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "vestedAmount",
    value: function vestedAmount(request) {
      var data = _query.QueryVestedAmountRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "VestedAmount", data);
      return promise.then(function (data) {
        return _query.QueryVestedAmountResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "task",
    value: function task(request) {
      var data = _query.QueryGetTaskRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "Task", data);
      return promise.then(function (data) {
        return _query.QueryGetTaskResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "taskAll",
    value: function taskAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllTaskRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "TaskAll", data);
      return promise.then(function (data) {
        return _query.QueryAllTaskResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "branchAll",
    value: function branchAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllBranchRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "BranchAll", data);
      return promise.then(function (data) {
        return _query.QueryAllBranchResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryBranch",
    value: function repositoryBranch(request) {
      var data = _query.QueryGetRepositoryBranchRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryBranch", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryBranchResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryBranchSha",
    value: function repositoryBranchSha(request) {
      var data = _query.QueryGetRepositoryBranchShaRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryBranchSha", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryBranchShaResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryBranchAll",
    value: function repositoryBranchAll(request) {
      var data = _query.QueryAllRepositoryBranchRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryBranchAll", data);
      return promise.then(function (data) {
        return _query.QueryAllRepositoryBranchResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "tagAll",
    value: function tagAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllTagRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "TagAll", data);
      return promise.then(function (data) {
        return _query.QueryAllTagResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryTag",
    value: function repositoryTag(request) {
      var data = _query.QueryGetRepositoryTagRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryTag", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryTagResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryTagSha",
    value: function repositoryTagSha(request) {
      var data = _query.QueryGetRepositoryTagShaRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryTagSha", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryTagShaResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryTagAll",
    value: function repositoryTagAll(request) {
      var data = _query.QueryAllRepositoryTagRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryTagAll", data);
      return promise.then(function (data) {
        return _query.QueryAllRepositoryTagResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "daoMember",
    value: function daoMember(request) {
      var data = _query.QueryGetDaoMemberRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "DaoMember", data);
      return promise.then(function (data) {
        return _query.QueryGetDaoMemberResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "daoMemberAll",
    value: function daoMemberAll(request) {
      var data = _query.QueryAllDaoMemberRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "DaoMemberAll", data);
      return promise.then(function (data) {
        return _query.QueryAllDaoMemberResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "memberAll",
    value: function memberAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllMemberRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "MemberAll", data);
      return promise.then(function (data) {
        return _query.QueryAllMemberResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "bounty",
    value: function bounty(request) {
      var data = _query.QueryGetBountyRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "Bounty", data);
      return promise.then(function (data) {
        return _query.QueryGetBountyResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "bountyAll",
    value: function bountyAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllBountyRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "BountyAll", data);
      return promise.then(function (data) {
        return _query.QueryAllBountyResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "release",
    value: function release(request) {
      var data = _query.QueryGetReleaseRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "Release", data);
      return promise.then(function (data) {
        return _query.QueryGetReleaseResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "releaseAll",
    value: function releaseAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllReleaseRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "ReleaseAll", data);
      return promise.then(function (data) {
        return _query.QueryAllReleaseResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "pullRequestAll",
    value: function pullRequestAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllPullRequestRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "PullRequestAll", data);
      return promise.then(function (data) {
        return _query.QueryAllPullRequestResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "dao",
    value: function dao(request) {
      var data = _query.QueryGetDaoRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "Dao", data);
      return promise.then(function (data) {
        return _query.QueryGetDaoResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "daoAll",
    value: function daoAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllDaoRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "DaoAll", data);
      return promise.then(function (data) {
        return _query.QueryAllDaoResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "issueComment",
    value: function issueComment(request) {
      var data = _query.QueryGetIssueCommentRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "IssueComment", data);
      return promise.then(function (data) {
        return _query.QueryGetIssueCommentResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "pullRequestComment",
    value: function pullRequestComment(request) {
      var data = _query.QueryGetPullRequestCommentRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "PullRequestComment", data);
      return promise.then(function (data) {
        return _query.QueryGetPullRequestCommentResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "commentAll",
    value: function commentAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllCommentRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "CommentAll", data);
      return promise.then(function (data) {
        return _query.QueryAllCommentResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "issueCommentAll",
    value: function issueCommentAll(request) {
      var data = _query.QueryAllIssueCommentRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "IssueCommentAll", data);
      return promise.then(function (data) {
        return _query.QueryAllIssueCommentResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "pullRequestCommentAll",
    value: function pullRequestCommentAll(request) {
      var data = _query.QueryAllPullRequestCommentRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "PullRequestCommentAll", data);
      return promise.then(function (data) {
        return _query.QueryAllPullRequestCommentResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "issueAll",
    value: function issueAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllIssueRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "IssueAll", data);
      return promise.then(function (data) {
        return _query.QueryAllIssueResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryReleaseLatest",
    value: function repositoryReleaseLatest(request) {
      var data = _query.QueryGetLatestRepositoryReleaseRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryReleaseLatest", data);
      return promise.then(function (data) {
        return _query.QueryGetLatestRepositoryReleaseResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryRelease",
    value: function repositoryRelease(request) {
      var data = _query.QueryGetRepositoryReleaseRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryRelease", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryReleaseResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryReleaseAll",
    value: function repositoryReleaseAll(request) {
      var data = _query.QueryAllRepositoryReleaseRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryReleaseAll", data);
      return promise.then(function (data) {
        return _query.QueryAllRepositoryReleaseResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryIssue",
    value: function repositoryIssue(request) {
      var data = _query.QueryGetRepositoryIssueRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryIssue", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryIssueResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryIssueAll",
    value: function repositoryIssueAll(request) {
      var data = _query.QueryAllRepositoryIssueRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryIssueAll", data);
      return promise.then(function (data) {
        return _query.QueryAllRepositoryIssueResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryPullRequest",
    value: function repositoryPullRequest(request) {
      var data = _query.QueryGetRepositoryPullRequestRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryPullRequest", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryPullRequestResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryPullRequestAll",
    value: function repositoryPullRequestAll(request) {
      var data = _query.QueryAllRepositoryPullRequestRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryPullRequestAll", data);
      return promise.then(function (data) {
        return _query.QueryAllRepositoryPullRequestResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repository",
    value: function repository(request) {
      var data = _query.QueryGetRepositoryRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "Repository", data);
      return promise.then(function (data) {
        return _query.QueryGetRepositoryResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "repositoryAll",
    value: function repositoryAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllRepositoryRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "RepositoryAll", data);
      return promise.then(function (data) {
        return _query.QueryAllRepositoryResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "forkAll",
    value: function forkAll(request) {
      var data = _query.QueryGetAllForkRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "ForkAll", data);
      return promise.then(function (data) {
        return _query.QueryGetAllForkResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "user",
    value: function user(request) {
      var data = _query.QueryGetUserRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "User", data);
      return promise.then(function (data) {
        return _query.QueryGetUserResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "userDaoAll",
    value: function userDaoAll(request) {
      var data = _query.QueryAllUserDaoRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "UserDaoAll", data);
      return promise.then(function (data) {
        return _query.QueryAllUserDaoResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "userAll",
    value: function userAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllUserRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "UserAll", data);
      return promise.then(function (data) {
        return _query.QueryAllUserResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "anyRepositoryAll",
    value: function anyRepositoryAll(request) {
      var data = _query.QueryAllAnyRepositoryRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "AnyRepositoryAll", data);
      return promise.then(function (data) {
        return _query.QueryAllAnyRepositoryResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "anyRepository",
    value: function anyRepository(request) {
      var data = _query.QueryGetAnyRepositoryRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "AnyRepository", data);
      return promise.then(function (data) {
        return _query.QueryGetAnyRepositoryResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "whois",
    value: function whois(request) {
      var data = _query.QueryGetWhoisRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "Whois", data);
      return promise.then(function (data) {
        return _query.QueryGetWhoisResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "whoisAll",
    value: function whoisAll() {
      var request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        pagination: undefined
      };
      var data = _query.QueryAllWhoisRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "WhoisAll", data);
      return promise.then(function (data) {
        return _query.QueryAllWhoisResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "pullRequestMergePermission",
    value: function pullRequestMergePermission(request) {
      var data = _query.QueryGetPullRequestMergePermissionRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "PullRequestMergePermission", data);
      return promise.then(function (data) {
        return _query.QueryGetPullRequestMergePermissionResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "checkGitServerAuthorization",
    value: function checkGitServerAuthorization(request) {
      var data = _query.QueryCheckGitServerAuthorizationRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "CheckGitServerAuthorization", data);
      return promise.then(function (data) {
        return _query.QueryCheckGitServerAuthorizationResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }, {
    key: "checkStorageProviderAuthorization",
    value: function checkStorageProviderAuthorization(request) {
      var data = _query.QueryCheckStorageProviderAuthorizationRequest.encode(request).finish();
      var promise = this.rpc.request("gitopia.gitopia.gitopia.Query", "CheckStorageProviderAuthorization", data);
      return promise.then(function (data) {
        return _query.QueryCheckStorageProviderAuthorizationResponse.decode(new _binary.BinaryReader(data));
      });
    }
  }]);
}();
var createRpcQueryExtension = exports.createRpcQueryExtension = function createRpcQueryExtension(base) {
  var rpc = (0, _stargate.createProtobufRpcClient)(base);
  var queryService = new QueryClientImpl(rpc);
  return {
    params: function params(request) {
      return queryService.params(request);
    },
    vestedAmount: function vestedAmount(request) {
      return queryService.vestedAmount(request);
    },
    task: function task(request) {
      return queryService.task(request);
    },
    taskAll: function taskAll(request) {
      return queryService.taskAll(request);
    },
    branchAll: function branchAll(request) {
      return queryService.branchAll(request);
    },
    repositoryBranch: function repositoryBranch(request) {
      return queryService.repositoryBranch(request);
    },
    repositoryBranchSha: function repositoryBranchSha(request) {
      return queryService.repositoryBranchSha(request);
    },
    repositoryBranchAll: function repositoryBranchAll(request) {
      return queryService.repositoryBranchAll(request);
    },
    tagAll: function tagAll(request) {
      return queryService.tagAll(request);
    },
    repositoryTag: function repositoryTag(request) {
      return queryService.repositoryTag(request);
    },
    repositoryTagSha: function repositoryTagSha(request) {
      return queryService.repositoryTagSha(request);
    },
    repositoryTagAll: function repositoryTagAll(request) {
      return queryService.repositoryTagAll(request);
    },
    daoMember: function daoMember(request) {
      return queryService.daoMember(request);
    },
    daoMemberAll: function daoMemberAll(request) {
      return queryService.daoMemberAll(request);
    },
    memberAll: function memberAll(request) {
      return queryService.memberAll(request);
    },
    bounty: function bounty(request) {
      return queryService.bounty(request);
    },
    bountyAll: function bountyAll(request) {
      return queryService.bountyAll(request);
    },
    release: function release(request) {
      return queryService.release(request);
    },
    releaseAll: function releaseAll(request) {
      return queryService.releaseAll(request);
    },
    pullRequestAll: function pullRequestAll(request) {
      return queryService.pullRequestAll(request);
    },
    dao: function dao(request) {
      return queryService.dao(request);
    },
    daoAll: function daoAll(request) {
      return queryService.daoAll(request);
    },
    issueComment: function issueComment(request) {
      return queryService.issueComment(request);
    },
    pullRequestComment: function pullRequestComment(request) {
      return queryService.pullRequestComment(request);
    },
    commentAll: function commentAll(request) {
      return queryService.commentAll(request);
    },
    issueCommentAll: function issueCommentAll(request) {
      return queryService.issueCommentAll(request);
    },
    pullRequestCommentAll: function pullRequestCommentAll(request) {
      return queryService.pullRequestCommentAll(request);
    },
    issueAll: function issueAll(request) {
      return queryService.issueAll(request);
    },
    repositoryReleaseLatest: function repositoryReleaseLatest(request) {
      return queryService.repositoryReleaseLatest(request);
    },
    repositoryRelease: function repositoryRelease(request) {
      return queryService.repositoryRelease(request);
    },
    repositoryReleaseAll: function repositoryReleaseAll(request) {
      return queryService.repositoryReleaseAll(request);
    },
    repositoryIssue: function repositoryIssue(request) {
      return queryService.repositoryIssue(request);
    },
    repositoryIssueAll: function repositoryIssueAll(request) {
      return queryService.repositoryIssueAll(request);
    },
    repositoryPullRequest: function repositoryPullRequest(request) {
      return queryService.repositoryPullRequest(request);
    },
    repositoryPullRequestAll: function repositoryPullRequestAll(request) {
      return queryService.repositoryPullRequestAll(request);
    },
    repository: function repository(request) {
      return queryService.repository(request);
    },
    repositoryAll: function repositoryAll(request) {
      return queryService.repositoryAll(request);
    },
    forkAll: function forkAll(request) {
      return queryService.forkAll(request);
    },
    user: function user(request) {
      return queryService.user(request);
    },
    userDaoAll: function userDaoAll(request) {
      return queryService.userDaoAll(request);
    },
    userAll: function userAll(request) {
      return queryService.userAll(request);
    },
    anyRepositoryAll: function anyRepositoryAll(request) {
      return queryService.anyRepositoryAll(request);
    },
    anyRepository: function anyRepository(request) {
      return queryService.anyRepository(request);
    },
    whois: function whois(request) {
      return queryService.whois(request);
    },
    whoisAll: function whoisAll(request) {
      return queryService.whoisAll(request);
    },
    pullRequestMergePermission: function pullRequestMergePermission(request) {
      return queryService.pullRequestMergePermission(request);
    },
    checkGitServerAuthorization: function checkGitServerAuthorization(request) {
      return queryService.checkGitServerAuthorization(request);
    },
    checkStorageProviderAuthorization: function checkStorageProviderAuthorization(request) {
      return queryService.checkStorageProviderAuthorization(request);
    }
  };
};