// Mocks generated by Mockito 5.3.2 from annotations
// in cocoon_service/test/src/utilities/mocks.dart.
// Do not manually edit this file.

// ignore_for_file: no_leading_underscores_for_library_prefixes
import 'dart:async' as _i17;
import 'dart:convert' as _i16;
import 'dart:io' as _i15;
import 'dart:typed_data' as _i27;

import 'package:cocoon_service/src/foundation/github_checks_util.dart' as _i11;
import 'package:cocoon_service/src/foundation/utils.dart' as _i35;
import 'package:cocoon_service/src/model/appengine/commit.dart' as _i34;
import 'package:cocoon_service/src/model/appengine/task.dart' as _i36;
import 'package:cocoon_service/src/model/ci_yaml/target.dart' as _i32;
import 'package:cocoon_service/src/model/github/checks.dart' as _i33;
import 'package:cocoon_service/src/model/luci/buildbucket.dart' as _i9;
import 'package:cocoon_service/src/model/luci/push_message.dart' as _i30;
import 'package:cocoon_service/src/request_handling/pubsub.dart' as _i19;
import 'package:cocoon_service/src/service/access_client_provider.dart' as _i5;
import 'package:cocoon_service/src/service/access_token_provider.dart' as _i21;
import 'package:cocoon_service/src/service/bigquery.dart' as _i22;
import 'package:cocoon_service/src/service/branch_service.dart' as _i23;
import 'package:cocoon_service/src/service/buildbucket.dart' as _i18;
import 'package:cocoon_service/src/service/config.dart' as _i3;
import 'package:cocoon_service/src/service/datastore.dart' as _i37;
import 'package:cocoon_service/src/service/gerrit_service.dart' as _i7;
import 'package:cocoon_service/src/service/github_checks_service.dart' as _i28;
import 'package:cocoon_service/src/service/github_service.dart' as _i25;
import 'package:cocoon_service/src/service/luci_build_service.dart' as _i31;
import 'package:cocoon_service/src/service/scheduler.dart' as _i29;
import 'package:github/github.dart' as _i10;
import 'package:github/hooks.dart' as _i24;
import 'package:googleapis/bigquery/v2.dart' as _i6;
import 'package:googleapis_auth/auth_io.dart' as _i4;
import 'package:graphql/src/cache/cache.dart' as _i13;
import 'package:graphql/src/core/core.dart' as _i12;
import 'package:graphql/src/graphql_client.dart' as _i14;
import 'package:http/http.dart' as _i2;
import 'package:mockito/mockito.dart' as _i1;
import 'package:mutex/mutex.dart' as _i39;
import 'package:neat_cache/neat_cache.dart' as _i20;
import 'package:process/src/interface/process_manager.dart' as _i38;
import 'package:retry/retry.dart' as _i8;

import '../../service/cache_service_test.dart' as _i26;
import 'mocks.dart' as _i40;

// ignore_for_file: type=lint
// ignore_for_file: avoid_redundant_argument_values
// ignore_for_file: avoid_setters_without_getters
// ignore_for_file: comment_references
// ignore_for_file: implementation_imports
// ignore_for_file: invalid_use_of_visible_for_testing_member
// ignore_for_file: prefer_const_constructors
// ignore_for_file: unnecessary_parenthesis
// ignore_for_file: camel_case_types
// ignore_for_file: subtype_of_sealed_class

class _FakeClient_0 extends _i1.SmartFake implements _i2.Client {
  _FakeClient_0(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeConfig_1 extends _i1.SmartFake implements _i3.Config {
  _FakeConfig_1(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeAccessToken_2 extends _i1.SmartFake implements _i4.AccessToken {
  _FakeAccessToken_2(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeAccessClientProvider_3 extends _i1.SmartFake
    implements _i5.AccessClientProvider {
  _FakeAccessClientProvider_3(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeTabledataResource_4 extends _i1.SmartFake
    implements _i6.TabledataResource {
  _FakeTabledataResource_4(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeJobsResource_5 extends _i1.SmartFake implements _i6.JobsResource {
  _FakeJobsResource_5(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGerritService_6 extends _i1.SmartFake implements _i7.GerritService {
  _FakeGerritService_6(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRetryOptions_7 extends _i1.SmartFake implements _i8.RetryOptions {
  _FakeRetryOptions_7(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeBuild_8 extends _i1.SmartFake implements _i9.Build {
  _FakeBuild_8(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeSearchBuildsResponse_9 extends _i1.SmartFake
    implements _i9.SearchBuildsResponse {
  _FakeSearchBuildsResponse_9(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeBatchResponse_10 extends _i1.SmartFake implements _i9.BatchResponse {
  _FakeBatchResponse_10(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeListBuildersResponse_11 extends _i1.SmartFake
    implements _i9.ListBuildersResponse {
  _FakeListBuildersResponse_11(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitHub_12 extends _i1.SmartFake implements _i10.GitHub {
  _FakeGitHub_12(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeIssue_13 extends _i1.SmartFake implements _i10.Issue {
  _FakeIssue_13(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeIssueComment_14 extends _i1.SmartFake implements _i10.IssueComment {
  _FakeIssueComment_14(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeIssueLabel_15 extends _i1.SmartFake implements _i10.IssueLabel {
  _FakeIssueLabel_15(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeMilestone_16 extends _i1.SmartFake implements _i10.Milestone {
  _FakeMilestone_16(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGithubChecksUtil_17 extends _i1.SmartFake
    implements _i11.GithubChecksUtil {
  _FakeGithubChecksUtil_17(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCheckRunConclusion_18 extends _i1.SmartFake
    implements _i10.CheckRunConclusion {
  _FakeCheckRunConclusion_18(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCheckRunStatus_19 extends _i1.SmartFake
    implements _i10.CheckRunStatus {
  _FakeCheckRunStatus_19(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCheckSuite_20 extends _i1.SmartFake implements _i10.CheckSuite {
  _FakeCheckSuite_20(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCheckRun_21 extends _i1.SmartFake implements _i10.CheckRun {
  _FakeCheckRun_21(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePullRequest_22 extends _i1.SmartFake implements _i10.PullRequest {
  _FakePullRequest_22(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitReference_23 extends _i1.SmartFake implements _i10.GitReference {
  _FakeGitReference_23(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRateLimit_24 extends _i1.SmartFake implements _i10.RateLimit {
  _FakeRateLimit_24(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitBlob_25 extends _i1.SmartFake implements _i10.GitBlob {
  _FakeGitBlob_25(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitCommit_26 extends _i1.SmartFake implements _i10.GitCommit {
  _FakeGitCommit_26(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitTag_27 extends _i1.SmartFake implements _i10.GitTag {
  _FakeGitTag_27(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitTree_28 extends _i1.SmartFake implements _i10.GitTree {
  _FakeGitTree_28(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeDefaultPolicies_29 extends _i1.SmartFake
    implements _i12.DefaultPolicies {
  _FakeDefaultPolicies_29(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeLink_30 extends _i1.SmartFake implements _i12.Link {
  _FakeLink_30(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGraphQLCache_31 extends _i1.SmartFake implements _i13.GraphQLCache {
  _FakeGraphQLCache_31(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeQueryManager_32 extends _i1.SmartFake implements _i12.QueryManager {
  _FakeQueryManager_32(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGraphQLClient_33 extends _i1.SmartFake
    implements _i14.GraphQLClient {
  _FakeGraphQLClient_33(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeObservableQuery_34<TParsed> extends _i1.SmartFake
    implements _i12.ObservableQuery<TParsed> {
  _FakeObservableQuery_34(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeQueryResult_35<TParsed extends Object?> extends _i1.SmartFake
    implements _i12.QueryResult<TParsed> {
  _FakeQueryResult_35(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeDuration_36 extends _i1.SmartFake implements Duration {
  _FakeDuration_36(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeHttpClientRequest_37 extends _i1.SmartFake
    implements _i15.HttpClientRequest {
  _FakeHttpClientRequest_37(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeUri_38 extends _i1.SmartFake implements Uri {
  _FakeUri_38(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeHttpHeaders_39 extends _i1.SmartFake implements _i15.HttpHeaders {
  _FakeHttpHeaders_39(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeHttpClientResponse_40 extends _i1.SmartFake
    implements _i15.HttpClientResponse {
  _FakeHttpClientResponse_40(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeEncoding_41 extends _i1.SmartFake implements _i16.Encoding {
  _FakeEncoding_41(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeSocket_42 extends _i1.SmartFake implements _i15.Socket {
  _FakeSocket_42(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeStreamSubscription_43<T> extends _i1.SmartFake
    implements _i17.StreamSubscription<T> {
  _FakeStreamSubscription_43(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeJobCancelResponse_44 extends _i1.SmartFake
    implements _i6.JobCancelResponse {
  _FakeJobCancelResponse_44(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeJob_45 extends _i1.SmartFake implements _i6.Job {
  _FakeJob_45(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGetQueryResultsResponse_46 extends _i1.SmartFake
    implements _i6.GetQueryResultsResponse {
  _FakeGetQueryResultsResponse_46(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeJobList_47 extends _i1.SmartFake implements _i6.JobList {
  _FakeJobList_47(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeQueryResponse_48 extends _i1.SmartFake implements _i6.QueryResponse {
  _FakeQueryResponse_48(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeBuildBucketClient_49 extends _i1.SmartFake
    implements _i18.BuildBucketClient {
  _FakeBuildBucketClient_49(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePubSub_50 extends _i1.SmartFake implements _i19.PubSub {
  _FakePubSub_50(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeProcess_51 extends _i1.SmartFake implements _i15.Process {
  _FakeProcess_51(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeProcessResult_52 extends _i1.SmartFake
    implements _i15.ProcessResult {
  _FakeProcessResult_52(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePullRequestMerge_53 extends _i1.SmartFake
    implements _i10.PullRequestMerge {
  _FakePullRequestMerge_53(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePullRequestComment_54 extends _i1.SmartFake
    implements _i10.PullRequestComment {
  _FakePullRequestComment_54(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePullRequestReview_55 extends _i1.SmartFake
    implements _i10.PullRequestReview {
  _FakePullRequestReview_55(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRepository_56 extends _i1.SmartFake implements _i10.Repository {
  _FakeRepository_56(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeLicenseDetails_57 extends _i1.SmartFake
    implements _i10.LicenseDetails {
  _FakeLicenseDetails_57(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeLanguageBreakdown_58 extends _i1.SmartFake
    implements _i10.LanguageBreakdown {
  _FakeLanguageBreakdown_58(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeBranch_59 extends _i1.SmartFake implements _i10.Branch {
  _FakeBranch_59(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCommitComment_60 extends _i1.SmartFake
    implements _i10.CommitComment {
  _FakeCommitComment_60(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRepositoryCommit_61 extends _i1.SmartFake
    implements _i10.RepositoryCommit {
  _FakeRepositoryCommit_61(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitHubComparison_62 extends _i1.SmartFake
    implements _i10.GitHubComparison {
  _FakeGitHubComparison_62(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitHubFile_63 extends _i1.SmartFake implements _i10.GitHubFile {
  _FakeGitHubFile_63(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRepositoryContents_64 extends _i1.SmartFake
    implements _i10.RepositoryContents {
  _FakeRepositoryContents_64(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeContentCreation_65 extends _i1.SmartFake
    implements _i10.ContentCreation {
  _FakeContentCreation_65(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeHook_66 extends _i1.SmartFake implements _i10.Hook {
  _FakeHook_66(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePublicKey_67 extends _i1.SmartFake implements _i10.PublicKey {
  _FakePublicKey_67(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRepositoryPages_68 extends _i1.SmartFake
    implements _i10.RepositoryPages {
  _FakeRepositoryPages_68(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePageBuild_69 extends _i1.SmartFake implements _i10.PageBuild {
  _FakePageBuild_69(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRelease_70 extends _i1.SmartFake implements _i10.Release {
  _FakeRelease_70(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeReleaseAsset_71 extends _i1.SmartFake implements _i10.ReleaseAsset {
  _FakeReleaseAsset_71(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeContributorParticipation_72 extends _i1.SmartFake
    implements _i10.ContributorParticipation {
  _FakeContributorParticipation_72(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRepositoryStatus_73 extends _i1.SmartFake
    implements _i10.RepositoryStatus {
  _FakeRepositoryStatus_73(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCombinedRepositoryStatus_74 extends _i1.SmartFake
    implements _i10.CombinedRepositoryStatus {
  _FakeCombinedRepositoryStatus_74(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeReleaseNotes_75 extends _i1.SmartFake implements _i10.ReleaseNotes {
  _FakeReleaseNotes_75(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeTableDataInsertAllResponse_76 extends _i1.SmartFake
    implements _i6.TableDataInsertAllResponse {
  _FakeTableDataInsertAllResponse_76(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeTableDataList_77 extends _i1.SmartFake implements _i6.TableDataList {
  _FakeTableDataList_77(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeUser_78 extends _i1.SmartFake implements _i10.User {
  _FakeUser_78(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCurrentUser_79 extends _i1.SmartFake implements _i10.CurrentUser {
  _FakeCurrentUser_79(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeEntry_80<T> extends _i1.SmartFake implements _i20.Entry<T> {
  _FakeEntry_80(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeCache_81<T> extends _i1.SmartFake implements _i20.Cache<T> {
  _FakeCache_81(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeActivityService_82 extends _i1.SmartFake
    implements _i10.ActivityService {
  _FakeActivityService_82(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeAuthorizationsService_83 extends _i1.SmartFake
    implements _i10.AuthorizationsService {
  _FakeAuthorizationsService_83(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGistsService_84 extends _i1.SmartFake implements _i10.GistsService {
  _FakeGistsService_84(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeGitService_85 extends _i1.SmartFake implements _i10.GitService {
  _FakeGitService_85(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeIssuesService_86 extends _i1.SmartFake
    implements _i10.IssuesService {
  _FakeIssuesService_86(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeMiscService_87 extends _i1.SmartFake implements _i10.MiscService {
  _FakeMiscService_87(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeOrganizationsService_88 extends _i1.SmartFake
    implements _i10.OrganizationsService {
  _FakeOrganizationsService_88(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakePullRequestsService_89 extends _i1.SmartFake
    implements _i10.PullRequestsService {
  _FakePullRequestsService_89(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeRepositoriesService_90 extends _i1.SmartFake
    implements _i10.RepositoriesService {
  _FakeRepositoriesService_90(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeSearchService_91 extends _i1.SmartFake
    implements _i10.SearchService {
  _FakeSearchService_91(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeUrlShortenerService_92 extends _i1.SmartFake
    implements _i10.UrlShortenerService {
  _FakeUrlShortenerService_92(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeUsersService_93 extends _i1.SmartFake implements _i10.UsersService {
  _FakeUsersService_93(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeChecksService_94 extends _i1.SmartFake
    implements _i10.ChecksService {
  _FakeChecksService_94(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

class _FakeResponse_95 extends _i1.SmartFake implements _i2.Response {
  _FakeResponse_95(
    Object parent,
    Invocation parentInvocation,
  ) : super(
          parent,
          parentInvocation,
        );
}

/// A class which mocks [AccessClientProvider].
///
/// See the documentation for Mockito's code generation for more information.
class MockAccessClientProvider extends _i1.Mock
    implements _i5.AccessClientProvider {
  MockAccessClientProvider() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i17.Future<_i2.Client> createAccessClient(
          {List<String>? scopes = const [
            r'https://www.googleapis.com/auth/cloud-platform'
          ]}) =>
      (super.noSuchMethod(
        Invocation.method(
          #createAccessClient,
          [],
          {#scopes: scopes},
        ),
        returnValue: _i17.Future<_i2.Client>.value(_FakeClient_0(
          this,
          Invocation.method(
            #createAccessClient,
            [],
            {#scopes: scopes},
          ),
        )),
      ) as _i17.Future<_i2.Client>);
}

/// A class which mocks [AccessTokenService].
///
/// See the documentation for Mockito's code generation for more information.
class MockAccessTokenService extends _i1.Mock
    implements _i21.AccessTokenService {
  MockAccessTokenService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i3.Config get config => (super.noSuchMethod(
        Invocation.getter(#config),
        returnValue: _FakeConfig_1(
          this,
          Invocation.getter(#config),
        ),
      ) as _i3.Config);
  @override
  _i17.Future<_i4.AccessToken> createAccessToken() => (super.noSuchMethod(
        Invocation.method(
          #createAccessToken,
          [],
        ),
        returnValue: _i17.Future<_i4.AccessToken>.value(_FakeAccessToken_2(
          this,
          Invocation.method(
            #createAccessToken,
            [],
          ),
        )),
      ) as _i17.Future<_i4.AccessToken>);
}

/// A class which mocks [BigqueryService].
///
/// See the documentation for Mockito's code generation for more information.
class MockBigqueryService extends _i1.Mock implements _i22.BigqueryService {
  MockBigqueryService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i5.AccessClientProvider get accessClientProvider => (super.noSuchMethod(
        Invocation.getter(#accessClientProvider),
        returnValue: _FakeAccessClientProvider_3(
          this,
          Invocation.getter(#accessClientProvider),
        ),
      ) as _i5.AccessClientProvider);
  @override
  _i17.Future<_i6.TabledataResource> defaultTabledata() => (super.noSuchMethod(
        Invocation.method(
          #defaultTabledata,
          [],
        ),
        returnValue:
            _i17.Future<_i6.TabledataResource>.value(_FakeTabledataResource_4(
          this,
          Invocation.method(
            #defaultTabledata,
            [],
          ),
        )),
      ) as _i17.Future<_i6.TabledataResource>);
  @override
  _i17.Future<_i6.JobsResource> defaultJobs() => (super.noSuchMethod(
        Invocation.method(
          #defaultJobs,
          [],
        ),
        returnValue: _i17.Future<_i6.JobsResource>.value(_FakeJobsResource_5(
          this,
          Invocation.method(
            #defaultJobs,
            [],
          ),
        )),
      ) as _i17.Future<_i6.JobsResource>);
  @override
  _i17.Future<List<_i22.BuilderStatistic>> listBuilderStatistic(
    String? projectId, {
    int? limit = 100,
    String? bucket = r'prod',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listBuilderStatistic,
          [projectId],
          {
            #limit: limit,
            #bucket: bucket,
          },
        ),
        returnValue: _i17.Future<List<_i22.BuilderStatistic>>.value(
            <_i22.BuilderStatistic>[]),
      ) as _i17.Future<List<_i22.BuilderStatistic>>);
  @override
  _i17.Future<List<_i22.BuilderRecord>> listRecentBuildRecordsForBuilder(
    String? projectId, {
    String? builder,
    int? limit,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listRecentBuildRecordsForBuilder,
          [projectId],
          {
            #builder: builder,
            #limit: limit,
          },
        ),
        returnValue:
            _i17.Future<List<_i22.BuilderRecord>>.value(<_i22.BuilderRecord>[]),
      ) as _i17.Future<List<_i22.BuilderRecord>>);
}

/// A class which mocks [BranchService].
///
/// See the documentation for Mockito's code generation for more information.
class MockBranchService extends _i1.Mock implements _i23.BranchService {
  MockBranchService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i3.Config get config => (super.noSuchMethod(
        Invocation.getter(#config),
        returnValue: _FakeConfig_1(
          this,
          Invocation.getter(#config),
        ),
      ) as _i3.Config);
  @override
  _i7.GerritService get gerritService => (super.noSuchMethod(
        Invocation.getter(#gerritService),
        returnValue: _FakeGerritService_6(
          this,
          Invocation.getter(#gerritService),
        ),
      ) as _i7.GerritService);
  @override
  _i8.RetryOptions get retryOptions => (super.noSuchMethod(
        Invocation.getter(#retryOptions),
        returnValue: _FakeRetryOptions_7(
          this,
          Invocation.getter(#retryOptions),
        ),
      ) as _i8.RetryOptions);
  @override
  _i17.Future<void> handleCreateRequest(_i24.CreateEvent? createEvent) =>
      (super.noSuchMethod(
        Invocation.method(
          #handleCreateRequest,
          [createEvent],
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<void> branchFlutterRecipes(String? branch) => (super.noSuchMethod(
        Invocation.method(
          #branchFlutterRecipes,
          [branch],
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<List<Map<String, String>>> getReleaseBranches({
    required _i25.GithubService? githubService,
    required _i10.RepositorySlug? slug,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getReleaseBranches,
          [],
          {
            #githubService: githubService,
            #slug: slug,
          },
        ),
        returnValue: _i17.Future<List<Map<String, String>>>.value(
            <Map<String, String>>[]),
      ) as _i17.Future<List<Map<String, String>>>);
}

/// A class which mocks [BuildBucketClient].
///
/// See the documentation for Mockito's code generation for more information.
// ignore: must_be_immutable
class MockBuildBucketClient extends _i1.Mock implements _i18.BuildBucketClient {
  MockBuildBucketClient() {
    _i1.throwOnMissingStub(this);
  }

  @override
  String get buildBucketBuildUri => (super.noSuchMethod(
        Invocation.getter(#buildBucketBuildUri),
        returnValue: '',
      ) as String);
  @override
  String get buildBucketBuilderUri => (super.noSuchMethod(
        Invocation.getter(#buildBucketBuilderUri),
        returnValue: '',
      ) as String);
  @override
  _i2.Client get httpClient => (super.noSuchMethod(
        Invocation.getter(#httpClient),
        returnValue: _FakeClient_0(
          this,
          Invocation.getter(#httpClient),
        ),
      ) as _i2.Client);
  @override
  _i17.Future<_i9.Build> scheduleBuild(
    _i9.ScheduleBuildRequest? request, {
    String? buildBucketUri =
        r'https://cr-buildbucket.appspot.com/prpc/buildbucket.v2.Builds',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #scheduleBuild,
          [request],
          {#buildBucketUri: buildBucketUri},
        ),
        returnValue: _i17.Future<_i9.Build>.value(_FakeBuild_8(
          this,
          Invocation.method(
            #scheduleBuild,
            [request],
            {#buildBucketUri: buildBucketUri},
          ),
        )),
      ) as _i17.Future<_i9.Build>);
  @override
  _i17.Future<_i9.SearchBuildsResponse> searchBuilds(
    _i9.SearchBuildsRequest? request, {
    String? buildBucketUri =
        r'https://cr-buildbucket.appspot.com/prpc/buildbucket.v2.Builds',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #searchBuilds,
          [request],
          {#buildBucketUri: buildBucketUri},
        ),
        returnValue: _i17.Future<_i9.SearchBuildsResponse>.value(
            _FakeSearchBuildsResponse_9(
          this,
          Invocation.method(
            #searchBuilds,
            [request],
            {#buildBucketUri: buildBucketUri},
          ),
        )),
      ) as _i17.Future<_i9.SearchBuildsResponse>);
  @override
  _i17.Future<_i9.BatchResponse> batch(
    _i9.BatchRequest? request, {
    String? buildBucketUri =
        r'https://cr-buildbucket.appspot.com/prpc/buildbucket.v2.Builds',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #batch,
          [request],
          {#buildBucketUri: buildBucketUri},
        ),
        returnValue: _i17.Future<_i9.BatchResponse>.value(_FakeBatchResponse_10(
          this,
          Invocation.method(
            #batch,
            [request],
            {#buildBucketUri: buildBucketUri},
          ),
        )),
      ) as _i17.Future<_i9.BatchResponse>);
  @override
  _i17.Future<_i9.Build> cancelBuild(
    _i9.CancelBuildRequest? request, {
    String? buildBucketUri =
        r'https://cr-buildbucket.appspot.com/prpc/buildbucket.v2.Builds',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #cancelBuild,
          [request],
          {#buildBucketUri: buildBucketUri},
        ),
        returnValue: _i17.Future<_i9.Build>.value(_FakeBuild_8(
          this,
          Invocation.method(
            #cancelBuild,
            [request],
            {#buildBucketUri: buildBucketUri},
          ),
        )),
      ) as _i17.Future<_i9.Build>);
  @override
  _i17.Future<_i9.Build> getBuild(
    _i9.GetBuildRequest? request, {
    String? buildBucketUri =
        r'https://cr-buildbucket.appspot.com/prpc/buildbucket.v2.Builds',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getBuild,
          [request],
          {#buildBucketUri: buildBucketUri},
        ),
        returnValue: _i17.Future<_i9.Build>.value(_FakeBuild_8(
          this,
          Invocation.method(
            #getBuild,
            [request],
            {#buildBucketUri: buildBucketUri},
          ),
        )),
      ) as _i17.Future<_i9.Build>);
  @override
  _i17.Future<_i9.ListBuildersResponse> listBuilders(
    _i9.ListBuildersRequest? request, {
    String? buildBucketUri =
        r'https://cr-buildbucket.appspot.com/prpc/buildbucket.v2.Builders',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listBuilders,
          [request],
          {#buildBucketUri: buildBucketUri},
        ),
        returnValue: _i17.Future<_i9.ListBuildersResponse>.value(
            _FakeListBuildersResponse_11(
          this,
          Invocation.method(
            #listBuilders,
            [request],
            {#buildBucketUri: buildBucketUri},
          ),
        )),
      ) as _i17.Future<_i9.ListBuildersResponse>);
  @override
  void close() => super.noSuchMethod(
        Invocation.method(
          #close,
          [],
        ),
        returnValueForMissingStub: null,
      );
}

/// A class which mocks [FakeEntry].
///
/// See the documentation for Mockito's code generation for more information.
class MockFakeEntry extends _i1.Mock implements _i26.FakeEntry {
  MockFakeEntry() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i27.Uint8List get value => (super.noSuchMethod(
        Invocation.getter(#value),
        returnValue: _i27.Uint8List(0),
      ) as _i27.Uint8List);
  @override
  set value(_i27.Uint8List? _value) => super.noSuchMethod(
        Invocation.setter(
          #value,
          _value,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i17.Future<_i27.Uint8List> get([
    _i17.Future<_i27.Uint8List?> Function()? create,
    Duration? ttl,
  ]) =>
      (super.noSuchMethod(
        Invocation.method(
          #get,
          [
            create,
            ttl,
          ],
        ),
        returnValue: _i17.Future<_i27.Uint8List>.value(_i27.Uint8List(0)),
      ) as _i17.Future<_i27.Uint8List>);
  @override
  _i17.Future<void> purge({int? retries = 0}) => (super.noSuchMethod(
        Invocation.method(
          #purge,
          [],
          {#retries: retries},
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<_i27.Uint8List?> set(
    _i27.Uint8List? value, [
    Duration? ttl,
  ]) =>
      (super.noSuchMethod(
        Invocation.method(
          #set,
          [
            value,
            ttl,
          ],
        ),
        returnValue: _i17.Future<_i27.Uint8List?>.value(),
      ) as _i17.Future<_i27.Uint8List?>);
}

/// A class which mocks [IssuesService].
///
/// See the documentation for Mockito's code generation for more information.
class MockIssuesService extends _i1.Mock implements _i10.IssuesService {
  MockIssuesService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i10.GitHub get github => (super.noSuchMethod(
        Invocation.getter(#github),
        returnValue: _FakeGitHub_12(
          this,
          Invocation.getter(#github),
        ),
      ) as _i10.GitHub);
  @override
  _i17.Stream<_i10.Issue> listAll({
    int? milestoneNumber,
    String? state,
    String? direction,
    String? sort,
    DateTime? since,
    int? perPage,
    List<String>? labels,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listAll,
          [],
          {
            #milestoneNumber: milestoneNumber,
            #state: state,
            #direction: direction,
            #sort: sort,
            #since: since,
            #perPage: perPage,
            #labels: labels,
          },
        ),
        returnValue: _i17.Stream<_i10.Issue>.empty(),
      ) as _i17.Stream<_i10.Issue>);
  @override
  _i17.Stream<_i10.Issue> listByUser({
    int? milestoneNumber,
    String? state,
    String? direction,
    String? sort,
    DateTime? since,
    int? perPage,
    List<String>? labels,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listByUser,
          [],
          {
            #milestoneNumber: milestoneNumber,
            #state: state,
            #direction: direction,
            #sort: sort,
            #since: since,
            #perPage: perPage,
            #labels: labels,
          },
        ),
        returnValue: _i17.Stream<_i10.Issue>.empty(),
      ) as _i17.Stream<_i10.Issue>);
  @override
  _i17.Stream<_i10.Issue> listByOrg(
    String? org, {
    int? milestoneNumber,
    String? state,
    String? direction,
    String? sort,
    DateTime? since,
    int? perPage,
    List<String>? labels,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listByOrg,
          [org],
          {
            #milestoneNumber: milestoneNumber,
            #state: state,
            #direction: direction,
            #sort: sort,
            #since: since,
            #perPage: perPage,
            #labels: labels,
          },
        ),
        returnValue: _i17.Stream<_i10.Issue>.empty(),
      ) as _i17.Stream<_i10.Issue>);
  @override
  _i17.Stream<_i10.Issue> listByRepo(
    _i10.RepositorySlug? slug, {
    int? milestoneNumber,
    String? state,
    String? direction,
    String? sort,
    DateTime? since,
    int? perPage,
    List<String>? labels,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listByRepo,
          [slug],
          {
            #milestoneNumber: milestoneNumber,
            #state: state,
            #direction: direction,
            #sort: sort,
            #since: since,
            #perPage: perPage,
            #labels: labels,
          },
        ),
        returnValue: _i17.Stream<_i10.Issue>.empty(),
      ) as _i17.Stream<_i10.Issue>);
  @override
  _i17.Stream<_i10.Reaction> listReactions(
    _i10.RepositorySlug? slug,
    int? issueNumber, {
    _i10.ReactionType? content,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listReactions,
          [
            slug,
            issueNumber,
          ],
          {#content: content},
        ),
        returnValue: _i17.Stream<_i10.Reaction>.empty(),
      ) as _i17.Stream<_i10.Reaction>);
  @override
  _i17.Future<_i10.Issue> edit(
    _i10.RepositorySlug? slug,
    int? issueNumber,
    _i10.IssueRequest? issue,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #edit,
          [
            slug,
            issueNumber,
            issue,
          ],
        ),
        returnValue: _i17.Future<_i10.Issue>.value(_FakeIssue_13(
          this,
          Invocation.method(
            #edit,
            [
              slug,
              issueNumber,
              issue,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Issue>);
  @override
  _i17.Future<_i10.Issue> get(
    _i10.RepositorySlug? slug,
    int? issueNumber,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #get,
          [
            slug,
            issueNumber,
          ],
        ),
        returnValue: _i17.Future<_i10.Issue>.value(_FakeIssue_13(
          this,
          Invocation.method(
            #get,
            [
              slug,
              issueNumber,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Issue>);
  @override
  _i17.Future<_i10.Issue> create(
    _i10.RepositorySlug? slug,
    _i10.IssueRequest? issue,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #create,
          [
            slug,
            issue,
          ],
        ),
        returnValue: _i17.Future<_i10.Issue>.value(_FakeIssue_13(
          this,
          Invocation.method(
            #create,
            [
              slug,
              issue,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Issue>);
  @override
  _i17.Stream<_i10.User> listAssignees(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listAssignees,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.User>.empty(),
      ) as _i17.Stream<_i10.User>);
  @override
  _i17.Future<bool> isAssignee(
    _i10.RepositorySlug? slug,
    String? repoName,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #isAssignee,
          [
            slug,
            repoName,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.IssueComment> listCommentsByIssue(
    _i10.RepositorySlug? slug,
    int? issueNumber,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommentsByIssue,
          [
            slug,
            issueNumber,
          ],
        ),
        returnValue: _i17.Stream<_i10.IssueComment>.empty(),
      ) as _i17.Stream<_i10.IssueComment>);
  @override
  _i17.Stream<_i10.IssueComment> listCommentsByRepo(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommentsByRepo,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.IssueComment>.empty(),
      ) as _i17.Stream<_i10.IssueComment>);
  @override
  _i17.Future<_i10.IssueComment> getComment(
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getComment,
          [
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<_i10.IssueComment>.value(_FakeIssueComment_14(
          this,
          Invocation.method(
            #getComment,
            [
              slug,
              id,
            ],
          ),
        )),
      ) as _i17.Future<_i10.IssueComment>);
  @override
  _i17.Future<_i10.IssueComment> createComment(
    _i10.RepositorySlug? slug,
    int? issueNumber,
    String? body,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createComment,
          [
            slug,
            issueNumber,
            body,
          ],
        ),
        returnValue: _i17.Future<_i10.IssueComment>.value(_FakeIssueComment_14(
          this,
          Invocation.method(
            #createComment,
            [
              slug,
              issueNumber,
              body,
            ],
          ),
        )),
      ) as _i17.Future<_i10.IssueComment>);
  @override
  _i17.Future<_i10.IssueComment> updateComment(
    _i10.RepositorySlug? slug,
    int? id,
    String? body,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #updateComment,
          [
            slug,
            id,
            body,
          ],
        ),
        returnValue: _i17.Future<_i10.IssueComment>.value(_FakeIssueComment_14(
          this,
          Invocation.method(
            #updateComment,
            [
              slug,
              id,
              body,
            ],
          ),
        )),
      ) as _i17.Future<_i10.IssueComment>);
  @override
  _i17.Future<bool> deleteComment(
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteComment,
          [
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.IssueLabel> listLabels(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listLabels,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.IssueLabel>.empty(),
      ) as _i17.Stream<_i10.IssueLabel>);
  @override
  _i17.Future<_i10.IssueLabel> getLabel(
    _i10.RepositorySlug? slug,
    String? name,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getLabel,
          [
            slug,
            name,
          ],
        ),
        returnValue: _i17.Future<_i10.IssueLabel>.value(_FakeIssueLabel_15(
          this,
          Invocation.method(
            #getLabel,
            [
              slug,
              name,
            ],
          ),
        )),
      ) as _i17.Future<_i10.IssueLabel>);
  @override
  _i17.Future<_i10.IssueLabel> createLabel(
    _i10.RepositorySlug? slug,
    String? name,
    String? color,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createLabel,
          [
            slug,
            name,
            color,
          ],
        ),
        returnValue: _i17.Future<_i10.IssueLabel>.value(_FakeIssueLabel_15(
          this,
          Invocation.method(
            #createLabel,
            [
              slug,
              name,
              color,
            ],
          ),
        )),
      ) as _i17.Future<_i10.IssueLabel>);
  @override
  _i17.Future<_i10.IssueLabel> editLabel(
    _i10.RepositorySlug? slug,
    String? name,
    String? color,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #editLabel,
          [
            slug,
            name,
            color,
          ],
        ),
        returnValue: _i17.Future<_i10.IssueLabel>.value(_FakeIssueLabel_15(
          this,
          Invocation.method(
            #editLabel,
            [
              slug,
              name,
              color,
            ],
          ),
        )),
      ) as _i17.Future<_i10.IssueLabel>);
  @override
  _i17.Future<bool> deleteLabel(
    _i10.RepositorySlug? slug,
    String? name,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteLabel,
          [
            slug,
            name,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.IssueLabel> listLabelsByIssue(
    _i10.RepositorySlug? slug,
    int? issueNumber,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listLabelsByIssue,
          [
            slug,
            issueNumber,
          ],
        ),
        returnValue: _i17.Stream<_i10.IssueLabel>.empty(),
      ) as _i17.Stream<_i10.IssueLabel>);
  @override
  _i17.Future<List<_i10.IssueLabel>> addLabelsToIssue(
    _i10.RepositorySlug? slug,
    int? issueNumber,
    List<String>? labels,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #addLabelsToIssue,
          [
            slug,
            issueNumber,
            labels,
          ],
        ),
        returnValue:
            _i17.Future<List<_i10.IssueLabel>>.value(<_i10.IssueLabel>[]),
      ) as _i17.Future<List<_i10.IssueLabel>>);
  @override
  _i17.Future<List<_i10.IssueLabel>> replaceLabelsForIssue(
    _i10.RepositorySlug? slug,
    int? issueNumber,
    List<String>? labels,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #replaceLabelsForIssue,
          [
            slug,
            issueNumber,
            labels,
          ],
        ),
        returnValue:
            _i17.Future<List<_i10.IssueLabel>>.value(<_i10.IssueLabel>[]),
      ) as _i17.Future<List<_i10.IssueLabel>>);
  @override
  _i17.Future<bool> removeLabelForIssue(
    _i10.RepositorySlug? slug,
    int? issueNumber,
    String? label,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #removeLabelForIssue,
          [
            slug,
            issueNumber,
            label,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> removeAllLabelsForIssue(
    _i10.RepositorySlug? slug,
    int? issueNumber,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #removeAllLabelsForIssue,
          [
            slug,
            issueNumber,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.Milestone> listMilestones(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listMilestones,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.Milestone>.empty(),
      ) as _i17.Stream<_i10.Milestone>);
  @override
  _i17.Future<_i10.Milestone> createMilestone(
    _i10.RepositorySlug? slug,
    _i10.CreateMilestone? request,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createMilestone,
          [
            slug,
            request,
          ],
        ),
        returnValue: _i17.Future<_i10.Milestone>.value(_FakeMilestone_16(
          this,
          Invocation.method(
            #createMilestone,
            [
              slug,
              request,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Milestone>);
  @override
  _i17.Future<bool> deleteMilestone(
    _i10.RepositorySlug? slug,
    int? number,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteMilestone,
          [
            slug,
            number,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
}

/// A class which mocks [GithubChecksService].
///
/// See the documentation for Mockito's code generation for more information.
class MockGithubChecksService extends _i1.Mock
    implements _i28.GithubChecksService {
  MockGithubChecksService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i3.Config get config => (super.noSuchMethod(
        Invocation.getter(#config),
        returnValue: _FakeConfig_1(
          this,
          Invocation.getter(#config),
        ),
      ) as _i3.Config);
  @override
  set config(_i3.Config? _config) => super.noSuchMethod(
        Invocation.setter(
          #config,
          _config,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i11.GithubChecksUtil get githubChecksUtil => (super.noSuchMethod(
        Invocation.getter(#githubChecksUtil),
        returnValue: _FakeGithubChecksUtil_17(
          this,
          Invocation.getter(#githubChecksUtil),
        ),
      ) as _i11.GithubChecksUtil);
  @override
  set githubChecksUtil(_i11.GithubChecksUtil? _githubChecksUtil) =>
      super.noSuchMethod(
        Invocation.setter(
          #githubChecksUtil,
          _githubChecksUtil,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i17.Future<void> handleCheckSuite(
    _i10.PullRequest? pullRequest,
    _i24.CheckSuiteEvent? checkSuiteEvent,
    _i29.Scheduler? scheduler,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #handleCheckSuite,
          [
            pullRequest,
            checkSuiteEvent,
            scheduler,
          ],
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<bool> updateCheckStatus(
    _i30.BuildPushMessage? buildPushMessage,
    _i31.LuciBuildService? luciBuildService,
    _i10.RepositorySlug? slug,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #updateCheckStatus,
          [
            buildPushMessage,
            luciBuildService,
            slug,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  String getGithubSummary(String? summary) => (super.noSuchMethod(
        Invocation.method(
          #getGithubSummary,
          [summary],
        ),
        returnValue: '',
      ) as String);
  @override
  _i10.CheckRunConclusion conclusionForResult(_i30.Result? result) =>
      (super.noSuchMethod(
        Invocation.method(
          #conclusionForResult,
          [result],
        ),
        returnValue: _FakeCheckRunConclusion_18(
          this,
          Invocation.method(
            #conclusionForResult,
            [result],
          ),
        ),
      ) as _i10.CheckRunConclusion);
  @override
  _i10.CheckRunStatus statusForResult(_i30.Status? status) =>
      (super.noSuchMethod(
        Invocation.method(
          #statusForResult,
          [status],
        ),
        returnValue: _FakeCheckRunStatus_19(
          this,
          Invocation.method(
            #statusForResult,
            [status],
          ),
        ),
      ) as _i10.CheckRunStatus);
}

/// A class which mocks [GithubChecksUtil].
///
/// See the documentation for Mockito's code generation for more information.
class MockGithubChecksUtil extends _i1.Mock implements _i11.GithubChecksUtil {
  MockGithubChecksUtil() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i17.Future<Map<String, _i10.CheckRun>> allCheckRuns(
    _i10.GitHub? gitHubClient,
    _i24.CheckSuiteEvent? checkSuiteEvent,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #allCheckRuns,
          [
            gitHubClient,
            checkSuiteEvent,
          ],
        ),
        returnValue: _i17.Future<Map<String, _i10.CheckRun>>.value(
            <String, _i10.CheckRun>{}),
      ) as _i17.Future<Map<String, _i10.CheckRun>>);
  @override
  _i17.Future<_i10.CheckSuite> getCheckSuite(
    _i10.GitHub? gitHubClient,
    _i10.RepositorySlug? slug,
    int? checkSuiteId,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getCheckSuite,
          [
            gitHubClient,
            slug,
            checkSuiteId,
          ],
        ),
        returnValue: _i17.Future<_i10.CheckSuite>.value(_FakeCheckSuite_20(
          this,
          Invocation.method(
            #getCheckSuite,
            [
              gitHubClient,
              slug,
              checkSuiteId,
            ],
          ),
        )),
      ) as _i17.Future<_i10.CheckSuite>);
  @override
  _i17.Future<void> updateCheckRun(
    _i3.Config? cocoonConfig,
    _i10.RepositorySlug? slug,
    _i10.CheckRun? checkRun, {
    _i10.CheckRunStatus? status = _i10.CheckRunStatus.queued,
    _i10.CheckRunConclusion? conclusion,
    String? detailsUrl,
    _i10.CheckRunOutput? output,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #updateCheckRun,
          [
            cocoonConfig,
            slug,
            checkRun,
          ],
          {
            #status: status,
            #conclusion: conclusion,
            #detailsUrl: detailsUrl,
            #output: output,
          },
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<_i10.CheckRun> getCheckRun(
    _i3.Config? cocoonConfig,
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getCheckRun,
          [
            cocoonConfig,
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<_i10.CheckRun>.value(_FakeCheckRun_21(
          this,
          Invocation.method(
            #getCheckRun,
            [
              cocoonConfig,
              slug,
              id,
            ],
          ),
        )),
      ) as _i17.Future<_i10.CheckRun>);
  @override
  _i17.Future<_i10.CheckRun> createCheckRun(
    _i3.Config? cocoonConfig,
    _i10.RepositorySlug? slug,
    String? sha,
    String? name, {
    _i10.CheckRunOutput? output,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #createCheckRun,
          [
            cocoonConfig,
            slug,
            sha,
            name,
          ],
          {#output: output},
        ),
        returnValue: _i17.Future<_i10.CheckRun>.value(_FakeCheckRun_21(
          this,
          Invocation.method(
            #createCheckRun,
            [
              cocoonConfig,
              slug,
              sha,
              name,
            ],
            {#output: output},
          ),
        )),
      ) as _i17.Future<_i10.CheckRun>);
}

/// A class which mocks [GithubService].
///
/// See the documentation for Mockito's code generation for more information.
class MockGithubService extends _i1.Mock implements _i25.GithubService {
  MockGithubService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i10.GitHub get github => (super.noSuchMethod(
        Invocation.getter(#github),
        returnValue: _FakeGitHub_12(
          this,
          Invocation.getter(#github),
        ),
      ) as _i10.GitHub);
  @override
  _i17.Future<List<_i10.RepositoryCommit>> listCommits(
    _i10.RepositorySlug? slug,
    String? branch,
    int? lastCommitTimestampMills,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommits,
          [
            slug,
            branch,
            lastCommitTimestampMills,
          ],
        ),
        returnValue: _i17.Future<List<_i10.RepositoryCommit>>.value(
            <_i10.RepositoryCommit>[]),
      ) as _i17.Future<List<_i10.RepositoryCommit>>);
  @override
  _i17.Future<List<_i10.PullRequest>> listPullRequests(
    _i10.RepositorySlug? slug,
    String? branch,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listPullRequests,
          [
            slug,
            branch,
          ],
        ),
        returnValue:
            _i17.Future<List<_i10.PullRequest>>.value(<_i10.PullRequest>[]),
      ) as _i17.Future<List<_i10.PullRequest>>);
  @override
  _i17.Future<_i10.PullRequest> createPullRequest(
    _i10.RepositorySlug? slug, {
    required String? title,
    String? body,
    String? commitMessage,
    required _i10.GitReference? baseRef,
    List<_i10.CreateGitTreeEntry>? entries,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #createPullRequest,
          [slug],
          {
            #title: title,
            #body: body,
            #commitMessage: commitMessage,
            #baseRef: baseRef,
            #entries: entries,
          },
        ),
        returnValue: _i17.Future<_i10.PullRequest>.value(_FakePullRequest_22(
          this,
          Invocation.method(
            #createPullRequest,
            [slug],
            {
              #title: title,
              #body: body,
              #commitMessage: commitMessage,
              #baseRef: baseRef,
              #entries: entries,
            },
          ),
        )),
      ) as _i17.Future<_i10.PullRequest>);
  @override
  _i17.Future<void> assignReviewer(
    _i10.RepositorySlug? slug, {
    int? pullRequestNumber,
    String? reviewer,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #assignReviewer,
          [slug],
          {
            #pullRequestNumber: pullRequestNumber,
            #reviewer: reviewer,
          },
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<List<_i10.Issue>> listIssues(
    _i10.RepositorySlug? slug, {
    List<String>? labels,
    String? state = r'open',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listIssues,
          [slug],
          {
            #labels: labels,
            #state: state,
          },
        ),
        returnValue: _i17.Future<List<_i10.Issue>>.value(<_i10.Issue>[]),
      ) as _i17.Future<List<_i10.Issue>>);
  @override
  _i17.Future<_i10.Issue>? getIssue(
    _i10.RepositorySlug? slug, {
    required int? issueNumber,
  }) =>
      (super.noSuchMethod(Invocation.method(
        #getIssue,
        [slug],
        {#issueNumber: issueNumber},
      )) as _i17.Future<_i10.Issue>?);
  @override
  _i17.Future<void> assignIssue(
    _i10.RepositorySlug? slug, {
    required int? issueNumber,
    required String? assignee,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #assignIssue,
          [slug],
          {
            #issueNumber: issueNumber,
            #assignee: assignee,
          },
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<_i10.Issue> createIssue(
    _i10.RepositorySlug? slug, {
    String? title,
    String? body,
    List<String>? labels,
    String? assignee,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #createIssue,
          [slug],
          {
            #title: title,
            #body: body,
            #labels: labels,
            #assignee: assignee,
          },
        ),
        returnValue: _i17.Future<_i10.Issue>.value(_FakeIssue_13(
          this,
          Invocation.method(
            #createIssue,
            [slug],
            {
              #title: title,
              #body: body,
              #labels: labels,
              #assignee: assignee,
            },
          ),
        )),
      ) as _i17.Future<_i10.Issue>);
  @override
  _i17.Future<_i10.IssueComment?> createComment(
    _i10.RepositorySlug? slug, {
    required int? issueNumber,
    required String? body,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #createComment,
          [slug],
          {
            #issueNumber: issueNumber,
            #body: body,
          },
        ),
        returnValue: _i17.Future<_i10.IssueComment?>.value(),
      ) as _i17.Future<_i10.IssueComment?>);
  @override
  _i17.Future<List<_i10.IssueLabel>> replaceLabelsForIssue(
    _i10.RepositorySlug? slug, {
    required int? issueNumber,
    required List<String>? labels,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #replaceLabelsForIssue,
          [slug],
          {
            #issueNumber: issueNumber,
            #labels: labels,
          },
        ),
        returnValue:
            _i17.Future<List<_i10.IssueLabel>>.value(<_i10.IssueLabel>[]),
      ) as _i17.Future<List<_i10.IssueLabel>>);
  @override
  _i17.Future<List<String>> listFiles(_i10.PullRequest? pullRequest) =>
      (super.noSuchMethod(
        Invocation.method(
          #listFiles,
          [pullRequest],
        ),
        returnValue: _i17.Future<List<String>>.value(<String>[]),
      ) as _i17.Future<List<String>>);
  @override
  _i17.Future<String> getFileContent(
    _i10.RepositorySlug? slug,
    String? path, {
    String? ref,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getFileContent,
          [
            slug,
            path,
          ],
          {#ref: ref},
        ),
        returnValue: _i17.Future<String>.value(''),
      ) as _i17.Future<String>);
  @override
  _i17.Future<_i10.GitReference> getReference(
    _i10.RepositorySlug? slug,
    String? ref,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getReference,
          [
            slug,
            ref,
          ],
        ),
        returnValue: _i17.Future<_i10.GitReference>.value(_FakeGitReference_23(
          this,
          Invocation.method(
            #getReference,
            [
              slug,
              ref,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitReference>);
  @override
  _i17.Future<_i10.RateLimit> getRateLimit() => (super.noSuchMethod(
        Invocation.method(
          #getRateLimit,
          [],
        ),
        returnValue: _i17.Future<_i10.RateLimit>.value(_FakeRateLimit_24(
          this,
          Invocation.method(
            #getRateLimit,
            [],
          ),
        )),
      ) as _i17.Future<_i10.RateLimit>);
}

/// A class which mocks [GitService].
///
/// See the documentation for Mockito's code generation for more information.
class MockGitService extends _i1.Mock implements _i10.GitService {
  MockGitService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i10.GitHub get github => (super.noSuchMethod(
        Invocation.getter(#github),
        returnValue: _FakeGitHub_12(
          this,
          Invocation.getter(#github),
        ),
      ) as _i10.GitHub);
  @override
  _i17.Future<_i10.GitBlob> getBlob(
    _i10.RepositorySlug? slug,
    String? sha,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getBlob,
          [
            slug,
            sha,
          ],
        ),
        returnValue: _i17.Future<_i10.GitBlob>.value(_FakeGitBlob_25(
          this,
          Invocation.method(
            #getBlob,
            [
              slug,
              sha,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitBlob>);
  @override
  _i17.Future<_i10.GitBlob> createBlob(
    _i10.RepositorySlug? slug,
    _i10.CreateGitBlob? blob,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createBlob,
          [
            slug,
            blob,
          ],
        ),
        returnValue: _i17.Future<_i10.GitBlob>.value(_FakeGitBlob_25(
          this,
          Invocation.method(
            #createBlob,
            [
              slug,
              blob,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitBlob>);
  @override
  _i17.Future<_i10.GitCommit> getCommit(
    _i10.RepositorySlug? slug,
    String? sha,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getCommit,
          [
            slug,
            sha,
          ],
        ),
        returnValue: _i17.Future<_i10.GitCommit>.value(_FakeGitCommit_26(
          this,
          Invocation.method(
            #getCommit,
            [
              slug,
              sha,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitCommit>);
  @override
  _i17.Future<_i10.GitCommit> createCommit(
    _i10.RepositorySlug? slug,
    _i10.CreateGitCommit? commit,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createCommit,
          [
            slug,
            commit,
          ],
        ),
        returnValue: _i17.Future<_i10.GitCommit>.value(_FakeGitCommit_26(
          this,
          Invocation.method(
            #createCommit,
            [
              slug,
              commit,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitCommit>);
  @override
  _i17.Future<_i10.GitReference> getReference(
    _i10.RepositorySlug? slug,
    String? ref,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getReference,
          [
            slug,
            ref,
          ],
        ),
        returnValue: _i17.Future<_i10.GitReference>.value(_FakeGitReference_23(
          this,
          Invocation.method(
            #getReference,
            [
              slug,
              ref,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitReference>);
  @override
  _i17.Stream<_i10.GitReference> listReferences(
    _i10.RepositorySlug? slug, {
    String? type,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listReferences,
          [slug],
          {#type: type},
        ),
        returnValue: _i17.Stream<_i10.GitReference>.empty(),
      ) as _i17.Stream<_i10.GitReference>);
  @override
  _i17.Future<_i10.GitReference> createReference(
    _i10.RepositorySlug? slug,
    String? ref,
    String? sha,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createReference,
          [
            slug,
            ref,
            sha,
          ],
        ),
        returnValue: _i17.Future<_i10.GitReference>.value(_FakeGitReference_23(
          this,
          Invocation.method(
            #createReference,
            [
              slug,
              ref,
              sha,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitReference>);
  @override
  _i17.Future<_i10.GitReference> editReference(
    _i10.RepositorySlug? slug,
    String? ref,
    String? sha, {
    bool? force = false,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #editReference,
          [
            slug,
            ref,
            sha,
          ],
          {#force: force},
        ),
        returnValue: _i17.Future<_i10.GitReference>.value(_FakeGitReference_23(
          this,
          Invocation.method(
            #editReference,
            [
              slug,
              ref,
              sha,
            ],
            {#force: force},
          ),
        )),
      ) as _i17.Future<_i10.GitReference>);
  @override
  _i17.Future<bool> deleteReference(
    _i10.RepositorySlug? slug,
    String? ref,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteReference,
          [
            slug,
            ref,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<_i10.GitTag> getTag(
    _i10.RepositorySlug? slug,
    String? sha,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getTag,
          [
            slug,
            sha,
          ],
        ),
        returnValue: _i17.Future<_i10.GitTag>.value(_FakeGitTag_27(
          this,
          Invocation.method(
            #getTag,
            [
              slug,
              sha,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitTag>);
  @override
  _i17.Future<_i10.GitTag> createTag(
    _i10.RepositorySlug? slug,
    _i10.CreateGitTag? tag,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createTag,
          [
            slug,
            tag,
          ],
        ),
        returnValue: _i17.Future<_i10.GitTag>.value(_FakeGitTag_27(
          this,
          Invocation.method(
            #createTag,
            [
              slug,
              tag,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitTag>);
  @override
  _i17.Future<_i10.GitTree> getTree(
    _i10.RepositorySlug? slug,
    String? sha, {
    bool? recursive = false,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getTree,
          [
            slug,
            sha,
          ],
          {#recursive: recursive},
        ),
        returnValue: _i17.Future<_i10.GitTree>.value(_FakeGitTree_28(
          this,
          Invocation.method(
            #getTree,
            [
              slug,
              sha,
            ],
            {#recursive: recursive},
          ),
        )),
      ) as _i17.Future<_i10.GitTree>);
  @override
  _i17.Future<_i10.GitTree> createTree(
    _i10.RepositorySlug? slug,
    _i10.CreateGitTree? tree,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createTree,
          [
            slug,
            tree,
          ],
        ),
        returnValue: _i17.Future<_i10.GitTree>.value(_FakeGitTree_28(
          this,
          Invocation.method(
            #createTree,
            [
              slug,
              tree,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitTree>);
}

/// A class which mocks [GraphQLClient].
///
/// See the documentation for Mockito's code generation for more information.
class MockGraphQLClient extends _i1.Mock implements _i14.GraphQLClient {
  MockGraphQLClient() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i12.DefaultPolicies get defaultPolicies => (super.noSuchMethod(
        Invocation.getter(#defaultPolicies),
        returnValue: _FakeDefaultPolicies_29(
          this,
          Invocation.getter(#defaultPolicies),
        ),
      ) as _i12.DefaultPolicies);
  @override
  set defaultPolicies(_i12.DefaultPolicies? _defaultPolicies) =>
      super.noSuchMethod(
        Invocation.setter(
          #defaultPolicies,
          _defaultPolicies,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i12.Link get link => (super.noSuchMethod(
        Invocation.getter(#link),
        returnValue: _FakeLink_30(
          this,
          Invocation.getter(#link),
        ),
      ) as _i12.Link);
  @override
  _i13.GraphQLCache get cache => (super.noSuchMethod(
        Invocation.getter(#cache),
        returnValue: _FakeGraphQLCache_31(
          this,
          Invocation.getter(#cache),
        ),
      ) as _i13.GraphQLCache);
  @override
  _i12.QueryManager get queryManager => (super.noSuchMethod(
        Invocation.getter(#queryManager),
        returnValue: _FakeQueryManager_32(
          this,
          Invocation.getter(#queryManager),
        ),
      ) as _i12.QueryManager);
  @override
  set queryManager(_i12.QueryManager? _queryManager) => super.noSuchMethod(
        Invocation.setter(
          #queryManager,
          _queryManager,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i14.GraphQLClient copyWith({
    _i12.Link? link,
    _i13.GraphQLCache? cache,
    _i12.DefaultPolicies? defaultPolicies,
    bool? alwaysRebroadcast,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #copyWith,
          [],
          {
            #link: link,
            #cache: cache,
            #defaultPolicies: defaultPolicies,
            #alwaysRebroadcast: alwaysRebroadcast,
          },
        ),
        returnValue: _FakeGraphQLClient_33(
          this,
          Invocation.method(
            #copyWith,
            [],
            {
              #link: link,
              #cache: cache,
              #defaultPolicies: defaultPolicies,
              #alwaysRebroadcast: alwaysRebroadcast,
            },
          ),
        ),
      ) as _i14.GraphQLClient);
  @override
  _i12.ObservableQuery<TParsed> watchQuery<TParsed>(
          _i12.WatchQueryOptions<TParsed>? options) =>
      (super.noSuchMethod(
        Invocation.method(
          #watchQuery,
          [options],
        ),
        returnValue: _FakeObservableQuery_34<TParsed>(
          this,
          Invocation.method(
            #watchQuery,
            [options],
          ),
        ),
      ) as _i12.ObservableQuery<TParsed>);
  @override
  _i12.ObservableQuery<TParsed> watchMutation<TParsed>(
          _i12.WatchQueryOptions<TParsed>? options) =>
      (super.noSuchMethod(
        Invocation.method(
          #watchMutation,
          [options],
        ),
        returnValue: _FakeObservableQuery_34<TParsed>(
          this,
          Invocation.method(
            #watchMutation,
            [options],
          ),
        ),
      ) as _i12.ObservableQuery<TParsed>);
  @override
  _i17.Future<_i12.QueryResult<TParsed>> query<TParsed>(
          _i12.QueryOptions<TParsed>? options) =>
      (super.noSuchMethod(
        Invocation.method(
          #query,
          [options],
        ),
        returnValue: _i17.Future<_i12.QueryResult<TParsed>>.value(
            _FakeQueryResult_35<TParsed>(
          this,
          Invocation.method(
            #query,
            [options],
          ),
        )),
      ) as _i17.Future<_i12.QueryResult<TParsed>>);
  @override
  _i17.Future<_i12.QueryResult<TParsed>> mutate<TParsed>(
          _i12.MutationOptions<TParsed>? options) =>
      (super.noSuchMethod(
        Invocation.method(
          #mutate,
          [options],
        ),
        returnValue: _i17.Future<_i12.QueryResult<TParsed>>.value(
            _FakeQueryResult_35<TParsed>(
          this,
          Invocation.method(
            #mutate,
            [options],
          ),
        )),
      ) as _i17.Future<_i12.QueryResult<TParsed>>);
  @override
  _i17.Stream<_i12.QueryResult<TParsed>> subscribe<TParsed>(
          _i12.SubscriptionOptions<TParsed>? options) =>
      (super.noSuchMethod(
        Invocation.method(
          #subscribe,
          [options],
        ),
        returnValue: _i17.Stream<_i12.QueryResult<TParsed>>.empty(),
      ) as _i17.Stream<_i12.QueryResult<TParsed>>);
  @override
  _i17.Future<_i12.QueryResult<TParsed>> fetchMore<TParsed>(
    _i12.FetchMoreOptions? fetchMoreOptions, {
    required _i12.QueryOptions<TParsed>? originalOptions,
    required _i12.QueryResult<TParsed>? previousResult,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #fetchMore,
          [fetchMoreOptions],
          {
            #originalOptions: originalOptions,
            #previousResult: previousResult,
          },
        ),
        returnValue: _i17.Future<_i12.QueryResult<TParsed>>.value(
            _FakeQueryResult_35<TParsed>(
          this,
          Invocation.method(
            #fetchMore,
            [fetchMoreOptions],
            {
              #originalOptions: originalOptions,
              #previousResult: previousResult,
            },
          ),
        )),
      ) as _i17.Future<_i12.QueryResult<TParsed>>);
  @override
  Map<String, dynamic>? readQuery(
    _i12.Request? request, {
    bool? optimistic = true,
  }) =>
      (super.noSuchMethod(Invocation.method(
        #readQuery,
        [request],
        {#optimistic: optimistic},
      )) as Map<String, dynamic>?);
  @override
  Map<String, dynamic>? readFragment(
    _i13.FragmentRequest? fragmentRequest, {
    bool? optimistic = true,
  }) =>
      (super.noSuchMethod(Invocation.method(
        #readFragment,
        [fragmentRequest],
        {#optimistic: optimistic},
      )) as Map<String, dynamic>?);
  @override
  void writeQuery(
    _i12.Request? request, {
    required Map<String, dynamic>? data,
    bool? broadcast = true,
  }) =>
      super.noSuchMethod(
        Invocation.method(
          #writeQuery,
          [request],
          {
            #data: data,
            #broadcast: broadcast,
          },
        ),
        returnValueForMissingStub: null,
      );
  @override
  void writeFragment(
    _i13.FragmentRequest? fragmentRequest, {
    bool? broadcast = true,
    required Map<String, dynamic>? data,
  }) =>
      super.noSuchMethod(
        Invocation.method(
          #writeFragment,
          [fragmentRequest],
          {
            #broadcast: broadcast,
            #data: data,
          },
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i17.Future<List<_i12.QueryResult<Object?>?>>? resetStore(
          {bool? refetchQueries = true}) =>
      (super.noSuchMethod(Invocation.method(
        #resetStore,
        [],
        {#refetchQueries: refetchQueries},
      )) as _i17.Future<List<_i12.QueryResult<Object?>?>>?);
}

/// A class which mocks [HttpClient].
///
/// See the documentation for Mockito's code generation for more information.
class MockHttpClient extends _i1.Mock implements _i15.HttpClient {
  MockHttpClient() {
    _i1.throwOnMissingStub(this);
  }

  @override
  Duration get idleTimeout => (super.noSuchMethod(
        Invocation.getter(#idleTimeout),
        returnValue: _FakeDuration_36(
          this,
          Invocation.getter(#idleTimeout),
        ),
      ) as Duration);
  @override
  set idleTimeout(Duration? _idleTimeout) => super.noSuchMethod(
        Invocation.setter(
          #idleTimeout,
          _idleTimeout,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set connectionTimeout(Duration? _connectionTimeout) => super.noSuchMethod(
        Invocation.setter(
          #connectionTimeout,
          _connectionTimeout,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set maxConnectionsPerHost(int? _maxConnectionsPerHost) => super.noSuchMethod(
        Invocation.setter(
          #maxConnectionsPerHost,
          _maxConnectionsPerHost,
        ),
        returnValueForMissingStub: null,
      );
  @override
  bool get autoUncompress => (super.noSuchMethod(
        Invocation.getter(#autoUncompress),
        returnValue: false,
      ) as bool);
  @override
  set autoUncompress(bool? _autoUncompress) => super.noSuchMethod(
        Invocation.setter(
          #autoUncompress,
          _autoUncompress,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set userAgent(String? _userAgent) => super.noSuchMethod(
        Invocation.setter(
          #userAgent,
          _userAgent,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set authenticate(
          _i17.Future<bool> Function(
    Uri,
    String,
    String?,
  )?
              f) =>
      super.noSuchMethod(
        Invocation.setter(
          #authenticate,
          f,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set connectionFactory(
          _i17.Future<_i15.ConnectionTask<_i15.Socket>> Function(
    Uri,
    String?,
    int?,
  )?
              f) =>
      super.noSuchMethod(
        Invocation.setter(
          #connectionFactory,
          f,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set findProxy(String Function(Uri)? f) => super.noSuchMethod(
        Invocation.setter(
          #findProxy,
          f,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set authenticateProxy(
          _i17.Future<bool> Function(
    String,
    int,
    String,
    String?,
  )?
              f) =>
      super.noSuchMethod(
        Invocation.setter(
          #authenticateProxy,
          f,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set badCertificateCallback(
          bool Function(
    _i15.X509Certificate,
    String,
    int,
  )?
              callback) =>
      super.noSuchMethod(
        Invocation.setter(
          #badCertificateCallback,
          callback,
        ),
        returnValueForMissingStub: null,
      );
  @override
  set keyLog(dynamic Function(String)? callback) => super.noSuchMethod(
        Invocation.setter(
          #keyLog,
          callback,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i17.Future<_i15.HttpClientRequest> open(
    String? method,
    String? host,
    int? port,
    String? path,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #open,
          [
            method,
            host,
            port,
            path,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #open,
            [
              method,
              host,
              port,
              path,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> openUrl(
    String? method,
    Uri? url,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #openUrl,
          [
            method,
            url,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #openUrl,
            [
              method,
              url,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> get(
    String? host,
    int? port,
    String? path,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #get,
          [
            host,
            port,
            path,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #get,
            [
              host,
              port,
              path,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> getUrl(Uri? url) => (super.noSuchMethod(
        Invocation.method(
          #getUrl,
          [url],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #getUrl,
            [url],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> post(
    String? host,
    int? port,
    String? path,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #post,
          [
            host,
            port,
            path,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #post,
            [
              host,
              port,
              path,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> postUrl(Uri? url) => (super.noSuchMethod(
        Invocation.method(
          #postUrl,
          [url],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #postUrl,
            [url],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> put(
    String? host,
    int? port,
    String? path,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #put,
          [
            host,
            port,
            path,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #put,
            [
              host,
              port,
              path,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> putUrl(Uri? url) => (super.noSuchMethod(
        Invocation.method(
          #putUrl,
          [url],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #putUrl,
            [url],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> delete(
    String? host,
    int? port,
    String? path,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #delete,
          [
            host,
            port,
            path,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #delete,
            [
              host,
              port,
              path,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> deleteUrl(Uri? url) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteUrl,
          [url],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #deleteUrl,
            [url],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> patch(
    String? host,
    int? port,
    String? path,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #patch,
          [
            host,
            port,
            path,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #patch,
            [
              host,
              port,
              path,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> patchUrl(Uri? url) => (super.noSuchMethod(
        Invocation.method(
          #patchUrl,
          [url],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #patchUrl,
            [url],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> head(
    String? host,
    int? port,
    String? path,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #head,
          [
            host,
            port,
            path,
          ],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #head,
            [
              host,
              port,
              path,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  _i17.Future<_i15.HttpClientRequest> headUrl(Uri? url) => (super.noSuchMethod(
        Invocation.method(
          #headUrl,
          [url],
        ),
        returnValue:
            _i17.Future<_i15.HttpClientRequest>.value(_FakeHttpClientRequest_37(
          this,
          Invocation.method(
            #headUrl,
            [url],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientRequest>);
  @override
  void addCredentials(
    Uri? url,
    String? realm,
    _i15.HttpClientCredentials? credentials,
  ) =>
      super.noSuchMethod(
        Invocation.method(
          #addCredentials,
          [
            url,
            realm,
            credentials,
          ],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void addProxyCredentials(
    String? host,
    int? port,
    String? realm,
    _i15.HttpClientCredentials? credentials,
  ) =>
      super.noSuchMethod(
        Invocation.method(
          #addProxyCredentials,
          [
            host,
            port,
            realm,
            credentials,
          ],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void close({bool? force = false}) => super.noSuchMethod(
        Invocation.method(
          #close,
          [],
          {#force: force},
        ),
        returnValueForMissingStub: null,
      );
}

/// A class which mocks [HttpClientRequest].
///
/// See the documentation for Mockito's code generation for more information.
class MockHttpClientRequest extends _i1.Mock implements _i15.HttpClientRequest {
  MockHttpClientRequest() {
    _i1.throwOnMissingStub(this);
  }

  @override
  bool get persistentConnection => (super.noSuchMethod(
        Invocation.getter(#persistentConnection),
        returnValue: false,
      ) as bool);
  @override
  set persistentConnection(bool? _persistentConnection) => super.noSuchMethod(
        Invocation.setter(
          #persistentConnection,
          _persistentConnection,
        ),
        returnValueForMissingStub: null,
      );
  @override
  bool get followRedirects => (super.noSuchMethod(
        Invocation.getter(#followRedirects),
        returnValue: false,
      ) as bool);
  @override
  set followRedirects(bool? _followRedirects) => super.noSuchMethod(
        Invocation.setter(
          #followRedirects,
          _followRedirects,
        ),
        returnValueForMissingStub: null,
      );
  @override
  int get maxRedirects => (super.noSuchMethod(
        Invocation.getter(#maxRedirects),
        returnValue: 0,
      ) as int);
  @override
  set maxRedirects(int? _maxRedirects) => super.noSuchMethod(
        Invocation.setter(
          #maxRedirects,
          _maxRedirects,
        ),
        returnValueForMissingStub: null,
      );
  @override
  int get contentLength => (super.noSuchMethod(
        Invocation.getter(#contentLength),
        returnValue: 0,
      ) as int);
  @override
  set contentLength(int? _contentLength) => super.noSuchMethod(
        Invocation.setter(
          #contentLength,
          _contentLength,
        ),
        returnValueForMissingStub: null,
      );
  @override
  bool get bufferOutput => (super.noSuchMethod(
        Invocation.getter(#bufferOutput),
        returnValue: false,
      ) as bool);
  @override
  set bufferOutput(bool? _bufferOutput) => super.noSuchMethod(
        Invocation.setter(
          #bufferOutput,
          _bufferOutput,
        ),
        returnValueForMissingStub: null,
      );
  @override
  String get method => (super.noSuchMethod(
        Invocation.getter(#method),
        returnValue: '',
      ) as String);
  @override
  Uri get uri => (super.noSuchMethod(
        Invocation.getter(#uri),
        returnValue: _FakeUri_38(
          this,
          Invocation.getter(#uri),
        ),
      ) as Uri);
  @override
  _i15.HttpHeaders get headers => (super.noSuchMethod(
        Invocation.getter(#headers),
        returnValue: _FakeHttpHeaders_39(
          this,
          Invocation.getter(#headers),
        ),
      ) as _i15.HttpHeaders);
  @override
  List<_i15.Cookie> get cookies => (super.noSuchMethod(
        Invocation.getter(#cookies),
        returnValue: <_i15.Cookie>[],
      ) as List<_i15.Cookie>);
  @override
  _i17.Future<_i15.HttpClientResponse> get done => (super.noSuchMethod(
        Invocation.getter(#done),
        returnValue: _i17.Future<_i15.HttpClientResponse>.value(
            _FakeHttpClientResponse_40(
          this,
          Invocation.getter(#done),
        )),
      ) as _i17.Future<_i15.HttpClientResponse>);
  @override
  _i16.Encoding get encoding => (super.noSuchMethod(
        Invocation.getter(#encoding),
        returnValue: _FakeEncoding_41(
          this,
          Invocation.getter(#encoding),
        ),
      ) as _i16.Encoding);
  @override
  set encoding(_i16.Encoding? _encoding) => super.noSuchMethod(
        Invocation.setter(
          #encoding,
          _encoding,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i17.Future<_i15.HttpClientResponse> close() => (super.noSuchMethod(
        Invocation.method(
          #close,
          [],
        ),
        returnValue: _i17.Future<_i15.HttpClientResponse>.value(
            _FakeHttpClientResponse_40(
          this,
          Invocation.method(
            #close,
            [],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientResponse>);
  @override
  void abort([
    Object? exception,
    StackTrace? stackTrace,
  ]) =>
      super.noSuchMethod(
        Invocation.method(
          #abort,
          [
            exception,
            stackTrace,
          ],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void add(List<int>? data) => super.noSuchMethod(
        Invocation.method(
          #add,
          [data],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void write(Object? object) => super.noSuchMethod(
        Invocation.method(
          #write,
          [object],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void writeAll(
    Iterable<dynamic>? objects, [
    String? separator = r'',
  ]) =>
      super.noSuchMethod(
        Invocation.method(
          #writeAll,
          [
            objects,
            separator,
          ],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void writeln([Object? object = r'']) => super.noSuchMethod(
        Invocation.method(
          #writeln,
          [object],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void writeCharCode(int? charCode) => super.noSuchMethod(
        Invocation.method(
          #writeCharCode,
          [charCode],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void addError(
    Object? error, [
    StackTrace? stackTrace,
  ]) =>
      super.noSuchMethod(
        Invocation.method(
          #addError,
          [
            error,
            stackTrace,
          ],
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i17.Future<dynamic> addStream(_i17.Stream<List<int>>? stream) =>
      (super.noSuchMethod(
        Invocation.method(
          #addStream,
          [stream],
        ),
        returnValue: _i17.Future<dynamic>.value(),
      ) as _i17.Future<dynamic>);
  @override
  _i17.Future<dynamic> flush() => (super.noSuchMethod(
        Invocation.method(
          #flush,
          [],
        ),
        returnValue: _i17.Future<dynamic>.value(),
      ) as _i17.Future<dynamic>);
}

/// A class which mocks [HttpClientResponse].
///
/// See the documentation for Mockito's code generation for more information.
class MockHttpClientResponse extends _i1.Mock
    implements _i15.HttpClientResponse {
  MockHttpClientResponse() {
    _i1.throwOnMissingStub(this);
  }

  @override
  int get statusCode => (super.noSuchMethod(
        Invocation.getter(#statusCode),
        returnValue: 0,
      ) as int);
  @override
  String get reasonPhrase => (super.noSuchMethod(
        Invocation.getter(#reasonPhrase),
        returnValue: '',
      ) as String);
  @override
  int get contentLength => (super.noSuchMethod(
        Invocation.getter(#contentLength),
        returnValue: 0,
      ) as int);
  @override
  _i15.HttpClientResponseCompressionState get compressionState =>
      (super.noSuchMethod(
        Invocation.getter(#compressionState),
        returnValue: _i15.HttpClientResponseCompressionState.notCompressed,
      ) as _i15.HttpClientResponseCompressionState);
  @override
  bool get persistentConnection => (super.noSuchMethod(
        Invocation.getter(#persistentConnection),
        returnValue: false,
      ) as bool);
  @override
  bool get isRedirect => (super.noSuchMethod(
        Invocation.getter(#isRedirect),
        returnValue: false,
      ) as bool);
  @override
  List<_i15.RedirectInfo> get redirects => (super.noSuchMethod(
        Invocation.getter(#redirects),
        returnValue: <_i15.RedirectInfo>[],
      ) as List<_i15.RedirectInfo>);
  @override
  _i15.HttpHeaders get headers => (super.noSuchMethod(
        Invocation.getter(#headers),
        returnValue: _FakeHttpHeaders_39(
          this,
          Invocation.getter(#headers),
        ),
      ) as _i15.HttpHeaders);
  @override
  List<_i15.Cookie> get cookies => (super.noSuchMethod(
        Invocation.getter(#cookies),
        returnValue: <_i15.Cookie>[],
      ) as List<_i15.Cookie>);
  @override
  bool get isBroadcast => (super.noSuchMethod(
        Invocation.getter(#isBroadcast),
        returnValue: false,
      ) as bool);
  @override
  _i17.Future<int> get length => (super.noSuchMethod(
        Invocation.getter(#length),
        returnValue: _i17.Future<int>.value(0),
      ) as _i17.Future<int>);
  @override
  _i17.Future<bool> get isEmpty => (super.noSuchMethod(
        Invocation.getter(#isEmpty),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<List<int>> get first => (super.noSuchMethod(
        Invocation.getter(#first),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Future<List<int>> get last => (super.noSuchMethod(
        Invocation.getter(#last),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Future<List<int>> get single => (super.noSuchMethod(
        Invocation.getter(#single),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Future<_i15.HttpClientResponse> redirect([
    String? method,
    Uri? url,
    bool? followLoops,
  ]) =>
      (super.noSuchMethod(
        Invocation.method(
          #redirect,
          [
            method,
            url,
            followLoops,
          ],
        ),
        returnValue: _i17.Future<_i15.HttpClientResponse>.value(
            _FakeHttpClientResponse_40(
          this,
          Invocation.method(
            #redirect,
            [
              method,
              url,
              followLoops,
            ],
          ),
        )),
      ) as _i17.Future<_i15.HttpClientResponse>);
  @override
  _i17.Future<_i15.Socket> detachSocket() => (super.noSuchMethod(
        Invocation.method(
          #detachSocket,
          [],
        ),
        returnValue: _i17.Future<_i15.Socket>.value(_FakeSocket_42(
          this,
          Invocation.method(
            #detachSocket,
            [],
          ),
        )),
      ) as _i17.Future<_i15.Socket>);
  @override
  _i17.Stream<List<int>> asBroadcastStream({
    void Function(_i17.StreamSubscription<List<int>>)? onListen,
    void Function(_i17.StreamSubscription<List<int>>)? onCancel,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #asBroadcastStream,
          [],
          {
            #onListen: onListen,
            #onCancel: onCancel,
          },
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.StreamSubscription<List<int>> listen(
    void Function(List<int>)? onData, {
    Function? onError,
    void Function()? onDone,
    bool? cancelOnError,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listen,
          [onData],
          {
            #onError: onError,
            #onDone: onDone,
            #cancelOnError: cancelOnError,
          },
        ),
        returnValue: _FakeStreamSubscription_43<List<int>>(
          this,
          Invocation.method(
            #listen,
            [onData],
            {
              #onError: onError,
              #onDone: onDone,
              #cancelOnError: cancelOnError,
            },
          ),
        ),
      ) as _i17.StreamSubscription<List<int>>);
  @override
  _i17.Stream<List<int>> where(bool Function(List<int>)? test) =>
      (super.noSuchMethod(
        Invocation.method(
          #where,
          [test],
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.Stream<S> map<S>(S Function(List<int>)? convert) => (super.noSuchMethod(
        Invocation.method(
          #map,
          [convert],
        ),
        returnValue: _i17.Stream<S>.empty(),
      ) as _i17.Stream<S>);
  @override
  _i17.Stream<E> asyncMap<E>(_i17.FutureOr<E> Function(List<int>)? convert) =>
      (super.noSuchMethod(
        Invocation.method(
          #asyncMap,
          [convert],
        ),
        returnValue: _i17.Stream<E>.empty(),
      ) as _i17.Stream<E>);
  @override
  _i17.Stream<E> asyncExpand<E>(_i17.Stream<E>? Function(List<int>)? convert) =>
      (super.noSuchMethod(
        Invocation.method(
          #asyncExpand,
          [convert],
        ),
        returnValue: _i17.Stream<E>.empty(),
      ) as _i17.Stream<E>);
  @override
  _i17.Stream<List<int>> handleError(
    Function? onError, {
    bool Function(dynamic)? test,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #handleError,
          [onError],
          {#test: test},
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.Stream<S> expand<S>(Iterable<S> Function(List<int>)? convert) =>
      (super.noSuchMethod(
        Invocation.method(
          #expand,
          [convert],
        ),
        returnValue: _i17.Stream<S>.empty(),
      ) as _i17.Stream<S>);
  @override
  _i17.Future<dynamic> pipe(_i17.StreamConsumer<List<int>>? streamConsumer) =>
      (super.noSuchMethod(
        Invocation.method(
          #pipe,
          [streamConsumer],
        ),
        returnValue: _i17.Future<dynamic>.value(),
      ) as _i17.Future<dynamic>);
  @override
  _i17.Stream<S> transform<S>(
          _i17.StreamTransformer<List<int>, S>? streamTransformer) =>
      (super.noSuchMethod(
        Invocation.method(
          #transform,
          [streamTransformer],
        ),
        returnValue: _i17.Stream<S>.empty(),
      ) as _i17.Stream<S>);
  @override
  _i17.Future<List<int>> reduce(
          List<int> Function(
    List<int>,
    List<int>,
  )?
              combine) =>
      (super.noSuchMethod(
        Invocation.method(
          #reduce,
          [combine],
        ),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Future<S> fold<S>(
    S? initialValue,
    S Function(
      S,
      List<int>,
    )?
        combine,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #fold,
          [
            initialValue,
            combine,
          ],
        ),
        returnValue: _i17.Future<S>.value(null),
      ) as _i17.Future<S>);
  @override
  _i17.Future<String> join([String? separator = r'']) => (super.noSuchMethod(
        Invocation.method(
          #join,
          [separator],
        ),
        returnValue: _i17.Future<String>.value(''),
      ) as _i17.Future<String>);
  @override
  _i17.Future<bool> contains(Object? needle) => (super.noSuchMethod(
        Invocation.method(
          #contains,
          [needle],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<dynamic> forEach(void Function(List<int>)? action) =>
      (super.noSuchMethod(
        Invocation.method(
          #forEach,
          [action],
        ),
        returnValue: _i17.Future<dynamic>.value(),
      ) as _i17.Future<dynamic>);
  @override
  _i17.Future<bool> every(bool Function(List<int>)? test) =>
      (super.noSuchMethod(
        Invocation.method(
          #every,
          [test],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> any(bool Function(List<int>)? test) => (super.noSuchMethod(
        Invocation.method(
          #any,
          [test],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<R> cast<R>() => (super.noSuchMethod(
        Invocation.method(
          #cast,
          [],
        ),
        returnValue: _i17.Stream<R>.empty(),
      ) as _i17.Stream<R>);
  @override
  _i17.Future<List<List<int>>> toList() => (super.noSuchMethod(
        Invocation.method(
          #toList,
          [],
        ),
        returnValue: _i17.Future<List<List<int>>>.value(<List<int>>[]),
      ) as _i17.Future<List<List<int>>>);
  @override
  _i17.Future<Set<List<int>>> toSet() => (super.noSuchMethod(
        Invocation.method(
          #toSet,
          [],
        ),
        returnValue: _i17.Future<Set<List<int>>>.value(<List<int>>{}),
      ) as _i17.Future<Set<List<int>>>);
  @override
  _i17.Future<E> drain<E>([E? futureValue]) => (super.noSuchMethod(
        Invocation.method(
          #drain,
          [futureValue],
        ),
        returnValue: _i17.Future<E>.value(null),
      ) as _i17.Future<E>);
  @override
  _i17.Stream<List<int>> take(int? count) => (super.noSuchMethod(
        Invocation.method(
          #take,
          [count],
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.Stream<List<int>> takeWhile(bool Function(List<int>)? test) =>
      (super.noSuchMethod(
        Invocation.method(
          #takeWhile,
          [test],
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.Stream<List<int>> skip(int? count) => (super.noSuchMethod(
        Invocation.method(
          #skip,
          [count],
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.Stream<List<int>> skipWhile(bool Function(List<int>)? test) =>
      (super.noSuchMethod(
        Invocation.method(
          #skipWhile,
          [test],
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.Stream<List<int>> distinct(
          [bool Function(
            List<int>,
            List<int>,
          )?
              equals]) =>
      (super.noSuchMethod(
        Invocation.method(
          #distinct,
          [equals],
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
  @override
  _i17.Future<List<int>> firstWhere(
    bool Function(List<int>)? test, {
    List<int> Function()? orElse,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #firstWhere,
          [test],
          {#orElse: orElse},
        ),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Future<List<int>> lastWhere(
    bool Function(List<int>)? test, {
    List<int> Function()? orElse,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #lastWhere,
          [test],
          {#orElse: orElse},
        ),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Future<List<int>> singleWhere(
    bool Function(List<int>)? test, {
    List<int> Function()? orElse,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #singleWhere,
          [test],
          {#orElse: orElse},
        ),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Future<List<int>> elementAt(int? index) => (super.noSuchMethod(
        Invocation.method(
          #elementAt,
          [index],
        ),
        returnValue: _i17.Future<List<int>>.value(<int>[]),
      ) as _i17.Future<List<int>>);
  @override
  _i17.Stream<List<int>> timeout(
    Duration? timeLimit, {
    void Function(_i17.EventSink<List<int>>)? onTimeout,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #timeout,
          [timeLimit],
          {#onTimeout: onTimeout},
        ),
        returnValue: _i17.Stream<List<int>>.empty(),
      ) as _i17.Stream<List<int>>);
}

/// A class which mocks [JobsResource].
///
/// See the documentation for Mockito's code generation for more information.
class MockJobsResource extends _i1.Mock implements _i6.JobsResource {
  MockJobsResource() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i17.Future<_i6.JobCancelResponse> cancel(
    String? projectId,
    String? jobId, {
    String? location,
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #cancel,
          [
            projectId,
            jobId,
          ],
          {
            #location: location,
            #$fields: $fields,
          },
        ),
        returnValue:
            _i17.Future<_i6.JobCancelResponse>.value(_FakeJobCancelResponse_44(
          this,
          Invocation.method(
            #cancel,
            [
              projectId,
              jobId,
            ],
            {
              #location: location,
              #$fields: $fields,
            },
          ),
        )),
      ) as _i17.Future<_i6.JobCancelResponse>);
  @override
  _i17.Future<void> delete(
    String? projectId,
    String? jobId, {
    String? location,
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #delete,
          [
            projectId,
            jobId,
          ],
          {
            #location: location,
            #$fields: $fields,
          },
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<_i6.Job> get(
    String? projectId,
    String? jobId, {
    String? location,
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #get,
          [
            projectId,
            jobId,
          ],
          {
            #location: location,
            #$fields: $fields,
          },
        ),
        returnValue: _i17.Future<_i6.Job>.value(_FakeJob_45(
          this,
          Invocation.method(
            #get,
            [
              projectId,
              jobId,
            ],
            {
              #location: location,
              #$fields: $fields,
            },
          ),
        )),
      ) as _i17.Future<_i6.Job>);
  @override
  _i17.Future<_i6.GetQueryResultsResponse> getQueryResults(
    String? projectId,
    String? jobId, {
    String? location,
    int? maxResults,
    String? pageToken,
    String? startIndex,
    int? timeoutMs,
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getQueryResults,
          [
            projectId,
            jobId,
          ],
          {
            #location: location,
            #maxResults: maxResults,
            #pageToken: pageToken,
            #startIndex: startIndex,
            #timeoutMs: timeoutMs,
            #$fields: $fields,
          },
        ),
        returnValue: _i17.Future<_i6.GetQueryResultsResponse>.value(
            _FakeGetQueryResultsResponse_46(
          this,
          Invocation.method(
            #getQueryResults,
            [
              projectId,
              jobId,
            ],
            {
              #location: location,
              #maxResults: maxResults,
              #pageToken: pageToken,
              #startIndex: startIndex,
              #timeoutMs: timeoutMs,
              #$fields: $fields,
            },
          ),
        )),
      ) as _i17.Future<_i6.GetQueryResultsResponse>);
  @override
  _i17.Future<_i6.Job> insert(
    _i6.Job? request,
    String? projectId, {
    String? $fields,
    _i6.UploadOptions? uploadOptions = _i6.UploadOptions.defaultOptions,
    _i6.Media? uploadMedia,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #insert,
          [
            request,
            projectId,
          ],
          {
            #$fields: $fields,
            #uploadOptions: uploadOptions,
            #uploadMedia: uploadMedia,
          },
        ),
        returnValue: _i17.Future<_i6.Job>.value(_FakeJob_45(
          this,
          Invocation.method(
            #insert,
            [
              request,
              projectId,
            ],
            {
              #$fields: $fields,
              #uploadOptions: uploadOptions,
              #uploadMedia: uploadMedia,
            },
          ),
        )),
      ) as _i17.Future<_i6.Job>);
  @override
  _i17.Future<_i6.JobList> list(
    String? projectId, {
    bool? allUsers,
    String? maxCreationTime,
    int? maxResults,
    String? minCreationTime,
    String? pageToken,
    String? parentJobId,
    String? projection,
    List<String>? stateFilter,
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #list,
          [projectId],
          {
            #allUsers: allUsers,
            #maxCreationTime: maxCreationTime,
            #maxResults: maxResults,
            #minCreationTime: minCreationTime,
            #pageToken: pageToken,
            #parentJobId: parentJobId,
            #projection: projection,
            #stateFilter: stateFilter,
            #$fields: $fields,
          },
        ),
        returnValue: _i17.Future<_i6.JobList>.value(_FakeJobList_47(
          this,
          Invocation.method(
            #list,
            [projectId],
            {
              #allUsers: allUsers,
              #maxCreationTime: maxCreationTime,
              #maxResults: maxResults,
              #minCreationTime: minCreationTime,
              #pageToken: pageToken,
              #parentJobId: parentJobId,
              #projection: projection,
              #stateFilter: stateFilter,
              #$fields: $fields,
            },
          ),
        )),
      ) as _i17.Future<_i6.JobList>);
  @override
  _i17.Future<_i6.QueryResponse> query(
    _i6.QueryRequest? request,
    String? projectId, {
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #query,
          [
            request,
            projectId,
          ],
          {#$fields: $fields},
        ),
        returnValue: _i17.Future<_i6.QueryResponse>.value(_FakeQueryResponse_48(
          this,
          Invocation.method(
            #query,
            [
              request,
              projectId,
            ],
            {#$fields: $fields},
          ),
        )),
      ) as _i17.Future<_i6.QueryResponse>);
}

/// A class which mocks [LuciBuildService].
///
/// See the documentation for Mockito's code generation for more information.
class MockLuciBuildService extends _i1.Mock implements _i31.LuciBuildService {
  MockLuciBuildService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i18.BuildBucketClient get buildBucketClient => (super.noSuchMethod(
        Invocation.getter(#buildBucketClient),
        returnValue: _FakeBuildBucketClient_49(
          this,
          Invocation.getter(#buildBucketClient),
        ),
      ) as _i18.BuildBucketClient);
  @override
  set buildBucketClient(_i18.BuildBucketClient? _buildBucketClient) =>
      super.noSuchMethod(
        Invocation.setter(
          #buildBucketClient,
          _buildBucketClient,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i3.Config get config => (super.noSuchMethod(
        Invocation.getter(#config),
        returnValue: _FakeConfig_1(
          this,
          Invocation.getter(#config),
        ),
      ) as _i3.Config);
  @override
  set config(_i3.Config? _config) => super.noSuchMethod(
        Invocation.setter(
          #config,
          _config,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i11.GithubChecksUtil get githubChecksUtil => (super.noSuchMethod(
        Invocation.getter(#githubChecksUtil),
        returnValue: _FakeGithubChecksUtil_17(
          this,
          Invocation.getter(#githubChecksUtil),
        ),
      ) as _i11.GithubChecksUtil);
  @override
  set githubChecksUtil(_i11.GithubChecksUtil? _githubChecksUtil) =>
      super.noSuchMethod(
        Invocation.setter(
          #githubChecksUtil,
          _githubChecksUtil,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i7.GerritService get gerritService => (super.noSuchMethod(
        Invocation.getter(#gerritService),
        returnValue: _FakeGerritService_6(
          this,
          Invocation.getter(#gerritService),
        ),
      ) as _i7.GerritService);
  @override
  set gerritService(_i7.GerritService? _gerritService) => super.noSuchMethod(
        Invocation.setter(
          #gerritService,
          _gerritService,
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i19.PubSub get pubsub => (super.noSuchMethod(
        Invocation.getter(#pubsub),
        returnValue: _FakePubSub_50(
          this,
          Invocation.getter(#pubsub),
        ),
      ) as _i19.PubSub);
  @override
  _i17.Future<List<List<_i9.Request>>> shard(
    List<_i9.Request>? requests,
    int? max,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #shard,
          [
            requests,
            max,
          ],
        ),
        returnValue:
            _i17.Future<List<List<_i9.Request>>>.value(<List<_i9.Request>>[]),
      ) as _i17.Future<List<List<_i9.Request>>>);
  @override
  _i17.Future<Iterable<_i9.Build>> getTryBuilds(
    _i10.RepositorySlug? slug,
    String? sha,
    String? builderName,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getTryBuilds,
          [
            slug,
            sha,
            builderName,
          ],
        ),
        returnValue: _i17.Future<Iterable<_i9.Build>>.value(<_i9.Build>[]),
      ) as _i17.Future<Iterable<_i9.Build>>);
  @override
  _i17.Future<Iterable<_i9.Build>> getProdBuilds(
    _i10.RepositorySlug? slug,
    String? commitSha,
    String? builderName,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getProdBuilds,
          [
            slug,
            commitSha,
            builderName,
          ],
        ),
        returnValue: _i17.Future<Iterable<_i9.Build>>.value(<_i9.Build>[]),
      ) as _i17.Future<Iterable<_i9.Build>>);
  @override
  _i17.Future<Iterable<_i9.Build>> getBuilds(
    _i10.RepositorySlug? slug,
    String? commitSha,
    String? builderName,
    String? bucket,
    Map<String, List<String>>? tags,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getBuilds,
          [
            slug,
            commitSha,
            builderName,
            bucket,
            tags,
          ],
        ),
        returnValue: _i17.Future<Iterable<_i9.Build>>.value(<_i9.Build>[]),
      ) as _i17.Future<Iterable<_i9.Build>>);
  @override
  _i17.Future<Map<String?, _i9.Build?>> tryBuildsForPullRequest(
          _i10.PullRequest? pullRequest) =>
      (super.noSuchMethod(
        Invocation.method(
          #tryBuildsForPullRequest,
          [pullRequest],
        ),
        returnValue: _i17.Future<Map<String?, _i9.Build?>>.value(
            <String?, _i9.Build?>{}),
      ) as _i17.Future<Map<String?, _i9.Build?>>);
  @override
  _i17.Future<List<_i32.Target>> scheduleTryBuilds({
    required List<_i32.Target>? targets,
    required _i10.PullRequest? pullRequest,
    _i24.CheckSuiteEvent? checkSuiteEvent,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #scheduleTryBuilds,
          [],
          {
            #targets: targets,
            #pullRequest: pullRequest,
            #checkSuiteEvent: checkSuiteEvent,
          },
        ),
        returnValue: _i17.Future<List<_i32.Target>>.value(<_i32.Target>[]),
      ) as _i17.Future<List<_i32.Target>>);
  @override
  _i17.Future<void> cancelBuilds(
    _i10.PullRequest? pullRequest,
    String? reason,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #cancelBuilds,
          [
            pullRequest,
            reason,
          ],
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<List<_i9.Build?>> failedBuilds(
    _i10.PullRequest? pullRequest,
    List<_i32.Target>? targets,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #failedBuilds,
          [
            pullRequest,
            targets,
          ],
        ),
        returnValue: _i17.Future<List<_i9.Build?>>.value(<_i9.Build?>[]),
      ) as _i17.Future<List<_i9.Build?>>);
  @override
  _i17.Future<_i9.Build> rescheduleBuild({
    required String? commitSha,
    required String? builderName,
    required _i30.BuildPushMessage? buildPushMessage,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #rescheduleBuild,
          [],
          {
            #commitSha: commitSha,
            #builderName: builderName,
            #buildPushMessage: buildPushMessage,
          },
        ),
        returnValue: _i17.Future<_i9.Build>.value(_FakeBuild_8(
          this,
          Invocation.method(
            #rescheduleBuild,
            [],
            {
              #commitSha: commitSha,
              #builderName: builderName,
              #buildPushMessage: buildPushMessage,
            },
          ),
        )),
      ) as _i17.Future<_i9.Build>);
  @override
  _i17.Future<_i9.Build> rescheduleUsingCheckRunEvent(
          _i33.CheckRunEvent? checkRunEvent) =>
      (super.noSuchMethod(
        Invocation.method(
          #rescheduleUsingCheckRunEvent,
          [checkRunEvent],
        ),
        returnValue: _i17.Future<_i9.Build>.value(_FakeBuild_8(
          this,
          Invocation.method(
            #rescheduleUsingCheckRunEvent,
            [checkRunEvent],
          ),
        )),
      ) as _i17.Future<_i9.Build>);
  @override
  _i17.Future<_i9.Build> getBuildById(
    String? id, {
    String? fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getBuildById,
          [id],
          {#fields: fields},
        ),
        returnValue: _i17.Future<_i9.Build>.value(_FakeBuild_8(
          this,
          Invocation.method(
            #getBuildById,
            [id],
            {#fields: fields},
          ),
        )),
      ) as _i17.Future<_i9.Build>);
  @override
  _i17.Future<Set<String>> getAvailableBuilderSet({
    String? project = r'flutter',
    String? bucket = r'prod',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getAvailableBuilderSet,
          [],
          {
            #project: project,
            #bucket: bucket,
          },
        ),
        returnValue: _i17.Future<Set<String>>.value(<String>{}),
      ) as _i17.Future<Set<String>>);
  @override
  _i17.Future<void> schedulePostsubmitBuilds({
    required _i34.Commit? commit,
    required List<_i35.Tuple<_i32.Target, _i36.Task, int>>? toBeScheduled,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #schedulePostsubmitBuilds,
          [],
          {
            #commit: commit,
            #toBeScheduled: toBeScheduled,
          },
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<void> createPostsubmitCheckRun(
    _i34.Commit? commit,
    _i32.Target? target,
    Map<String, dynamic>? rawUserData,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createPostsubmitCheckRun,
          [
            commit,
            target,
            rawUserData,
          ],
        ),
        returnValue: _i17.Future<void>.value(),
        returnValueForMissingStub: _i17.Future<void>.value(),
      ) as _i17.Future<void>);
  @override
  _i17.Future<bool> checkRerunBuilder({
    required _i34.Commit? commit,
    required _i32.Target? target,
    required _i36.Task? task,
    required _i37.DatastoreService? datastore,
    Map<String, List<String>>? tags,
    bool? ignoreChecks = false,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #checkRerunBuilder,
          [],
          {
            #commit: commit,
            #target: target,
            #task: task,
            #datastore: datastore,
            #tags: tags,
            #ignoreChecks: ignoreChecks,
          },
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
}

/// A class which mocks [ProcessManager].
///
/// See the documentation for Mockito's code generation for more information.
class MockProcessManager extends _i1.Mock implements _i38.ProcessManager {
  MockProcessManager() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i17.Future<_i15.Process> start(
    List<Object>? command, {
    String? workingDirectory,
    Map<String, String>? environment,
    bool? includeParentEnvironment = true,
    bool? runInShell = false,
    _i15.ProcessStartMode? mode = _i15.ProcessStartMode.normal,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #start,
          [command],
          {
            #workingDirectory: workingDirectory,
            #environment: environment,
            #includeParentEnvironment: includeParentEnvironment,
            #runInShell: runInShell,
            #mode: mode,
          },
        ),
        returnValue: _i17.Future<_i15.Process>.value(_FakeProcess_51(
          this,
          Invocation.method(
            #start,
            [command],
            {
              #workingDirectory: workingDirectory,
              #environment: environment,
              #includeParentEnvironment: includeParentEnvironment,
              #runInShell: runInShell,
              #mode: mode,
            },
          ),
        )),
      ) as _i17.Future<_i15.Process>);
  @override
  _i17.Future<_i15.ProcessResult> run(
    List<Object>? command, {
    String? workingDirectory,
    Map<String, String>? environment,
    bool? includeParentEnvironment = true,
    bool? runInShell = false,
    _i16.Encoding? stdoutEncoding = const _i15.SystemEncoding(),
    _i16.Encoding? stderrEncoding = const _i15.SystemEncoding(),
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #run,
          [command],
          {
            #workingDirectory: workingDirectory,
            #environment: environment,
            #includeParentEnvironment: includeParentEnvironment,
            #runInShell: runInShell,
            #stdoutEncoding: stdoutEncoding,
            #stderrEncoding: stderrEncoding,
          },
        ),
        returnValue:
            _i17.Future<_i15.ProcessResult>.value(_FakeProcessResult_52(
          this,
          Invocation.method(
            #run,
            [command],
            {
              #workingDirectory: workingDirectory,
              #environment: environment,
              #includeParentEnvironment: includeParentEnvironment,
              #runInShell: runInShell,
              #stdoutEncoding: stdoutEncoding,
              #stderrEncoding: stderrEncoding,
            },
          ),
        )),
      ) as _i17.Future<_i15.ProcessResult>);
  @override
  _i15.ProcessResult runSync(
    List<Object>? command, {
    String? workingDirectory,
    Map<String, String>? environment,
    bool? includeParentEnvironment = true,
    bool? runInShell = false,
    _i16.Encoding? stdoutEncoding = const _i15.SystemEncoding(),
    _i16.Encoding? stderrEncoding = const _i15.SystemEncoding(),
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #runSync,
          [command],
          {
            #workingDirectory: workingDirectory,
            #environment: environment,
            #includeParentEnvironment: includeParentEnvironment,
            #runInShell: runInShell,
            #stdoutEncoding: stdoutEncoding,
            #stderrEncoding: stderrEncoding,
          },
        ),
        returnValue: _FakeProcessResult_52(
          this,
          Invocation.method(
            #runSync,
            [command],
            {
              #workingDirectory: workingDirectory,
              #environment: environment,
              #includeParentEnvironment: includeParentEnvironment,
              #runInShell: runInShell,
              #stdoutEncoding: stdoutEncoding,
              #stderrEncoding: stderrEncoding,
            },
          ),
        ),
      ) as _i15.ProcessResult);
  @override
  bool canRun(
    dynamic executable, {
    String? workingDirectory,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #canRun,
          [executable],
          {#workingDirectory: workingDirectory},
        ),
        returnValue: false,
      ) as bool);
  @override
  bool killPid(
    int? pid, [
    _i15.ProcessSignal? signal = _i15.ProcessSignal.sigterm,
  ]) =>
      (super.noSuchMethod(
        Invocation.method(
          #killPid,
          [
            pid,
            signal,
          ],
        ),
        returnValue: false,
      ) as bool);
}

/// A class which mocks [PullRequestsService].
///
/// See the documentation for Mockito's code generation for more information.
class MockPullRequestsService extends _i1.Mock
    implements _i10.PullRequestsService {
  MockPullRequestsService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i10.GitHub get github => (super.noSuchMethod(
        Invocation.getter(#github),
        returnValue: _FakeGitHub_12(
          this,
          Invocation.getter(#github),
        ),
      ) as _i10.GitHub);
  @override
  _i17.Stream<_i10.PullRequest> list(
    _i10.RepositorySlug? slug, {
    int? pages,
    String? base,
    String? direction = r'desc',
    String? head,
    String? sort = r'created',
    String? state = r'open',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #list,
          [slug],
          {
            #pages: pages,
            #base: base,
            #direction: direction,
            #head: head,
            #sort: sort,
            #state: state,
          },
        ),
        returnValue: _i17.Stream<_i10.PullRequest>.empty(),
      ) as _i17.Stream<_i10.PullRequest>);
  @override
  _i17.Future<_i10.PullRequest> get(
    _i10.RepositorySlug? slug,
    int? number,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #get,
          [
            slug,
            number,
          ],
        ),
        returnValue: _i17.Future<_i10.PullRequest>.value(_FakePullRequest_22(
          this,
          Invocation.method(
            #get,
            [
              slug,
              number,
            ],
          ),
        )),
      ) as _i17.Future<_i10.PullRequest>);
  @override
  _i17.Future<_i10.PullRequest> create(
    _i10.RepositorySlug? slug,
    _i10.CreatePullRequest? request,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #create,
          [
            slug,
            request,
          ],
        ),
        returnValue: _i17.Future<_i10.PullRequest>.value(_FakePullRequest_22(
          this,
          Invocation.method(
            #create,
            [
              slug,
              request,
            ],
          ),
        )),
      ) as _i17.Future<_i10.PullRequest>);
  @override
  _i17.Future<_i10.PullRequest> edit(
    _i10.RepositorySlug? slug,
    int? number, {
    String? title,
    String? body,
    String? state,
    String? base,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #edit,
          [
            slug,
            number,
          ],
          {
            #title: title,
            #body: body,
            #state: state,
            #base: base,
          },
        ),
        returnValue: _i17.Future<_i10.PullRequest>.value(_FakePullRequest_22(
          this,
          Invocation.method(
            #edit,
            [
              slug,
              number,
            ],
            {
              #title: title,
              #body: body,
              #state: state,
              #base: base,
            },
          ),
        )),
      ) as _i17.Future<_i10.PullRequest>);
  @override
  _i17.Stream<_i10.RepositoryCommit> listCommits(
    _i10.RepositorySlug? slug,
    int? number,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommits,
          [
            slug,
            number,
          ],
        ),
        returnValue: _i17.Stream<_i10.RepositoryCommit>.empty(),
      ) as _i17.Stream<_i10.RepositoryCommit>);
  @override
  _i17.Stream<_i10.PullRequestFile> listFiles(
    _i10.RepositorySlug? slug,
    int? number,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listFiles,
          [
            slug,
            number,
          ],
        ),
        returnValue: _i17.Stream<_i10.PullRequestFile>.empty(),
      ) as _i17.Stream<_i10.PullRequestFile>);
  @override
  _i17.Stream<_i10.PullRequestReview> listReviews(
    _i10.RepositorySlug? slug,
    int? number,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listReviews,
          [
            slug,
            number,
          ],
        ),
        returnValue: _i17.Stream<_i10.PullRequestReview>.empty(),
      ) as _i17.Stream<_i10.PullRequestReview>);
  @override
  _i17.Future<bool> isMerged(
    _i10.RepositorySlug? slug,
    int? number,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #isMerged,
          [
            slug,
            number,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<_i10.PullRequestMerge> merge(
    _i10.RepositorySlug? slug,
    int? number, {
    String? message,
    _i10.MergeMethod? mergeMethod = _i10.MergeMethod.merge,
    String? requestSha,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #merge,
          [
            slug,
            number,
          ],
          {
            #message: message,
            #mergeMethod: mergeMethod,
            #requestSha: requestSha,
          },
        ),
        returnValue:
            _i17.Future<_i10.PullRequestMerge>.value(_FakePullRequestMerge_53(
          this,
          Invocation.method(
            #merge,
            [
              slug,
              number,
            ],
            {
              #message: message,
              #mergeMethod: mergeMethod,
              #requestSha: requestSha,
            },
          ),
        )),
      ) as _i17.Future<_i10.PullRequestMerge>);
  @override
  _i17.Stream<_i10.PullRequestComment> listCommentsByPullRequest(
    _i10.RepositorySlug? slug,
    int? number,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommentsByPullRequest,
          [
            slug,
            number,
          ],
        ),
        returnValue: _i17.Stream<_i10.PullRequestComment>.empty(),
      ) as _i17.Stream<_i10.PullRequestComment>);
  @override
  _i17.Stream<_i10.PullRequestComment> listComments(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listComments,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.PullRequestComment>.empty(),
      ) as _i17.Stream<_i10.PullRequestComment>);
  @override
  _i17.Future<_i10.PullRequestComment> createComment(
    _i10.RepositorySlug? slug,
    int? number,
    _i10.CreatePullRequestComment? comment,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createComment,
          [
            slug,
            number,
            comment,
          ],
        ),
        returnValue: _i17.Future<_i10.PullRequestComment>.value(
            _FakePullRequestComment_54(
          this,
          Invocation.method(
            #createComment,
            [
              slug,
              number,
              comment,
            ],
          ),
        )),
      ) as _i17.Future<_i10.PullRequestComment>);
  @override
  _i17.Future<_i10.PullRequestReview> createReview(
    _i10.RepositorySlug? slug,
    _i10.CreatePullRequestReview? review,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createReview,
          [
            slug,
            review,
          ],
        ),
        returnValue:
            _i17.Future<_i10.PullRequestReview>.value(_FakePullRequestReview_55(
          this,
          Invocation.method(
            #createReview,
            [
              slug,
              review,
            ],
          ),
        )),
      ) as _i17.Future<_i10.PullRequestReview>);
}

/// A class which mocks [ReadWriteMutex].
///
/// See the documentation for Mockito's code generation for more information.
class MockReadWriteMutex extends _i1.Mock implements _i39.ReadWriteMutex {
  MockReadWriteMutex() {
    _i1.throwOnMissingStub(this);
  }

  @override
  bool get isLocked => (super.noSuchMethod(
        Invocation.getter(#isLocked),
        returnValue: false,
      ) as bool);
  @override
  bool get isWriteLocked => (super.noSuchMethod(
        Invocation.getter(#isWriteLocked),
        returnValue: false,
      ) as bool);
  @override
  bool get isReadLocked => (super.noSuchMethod(
        Invocation.getter(#isReadLocked),
        returnValue: false,
      ) as bool);
  @override
  _i17.Future<dynamic> acquireRead() => (super.noSuchMethod(
        Invocation.method(
          #acquireRead,
          [],
        ),
        returnValue: _i17.Future<dynamic>.value(),
      ) as _i17.Future<dynamic>);
  @override
  _i17.Future<dynamic> acquireWrite() => (super.noSuchMethod(
        Invocation.method(
          #acquireWrite,
          [],
        ),
        returnValue: _i17.Future<dynamic>.value(),
      ) as _i17.Future<dynamic>);
  @override
  void release() => super.noSuchMethod(
        Invocation.method(
          #release,
          [],
        ),
        returnValueForMissingStub: null,
      );
  @override
  _i17.Future<T> protectRead<T>(_i17.Future<T> Function()? criticalSection) =>
      (super.noSuchMethod(
        Invocation.method(
          #protectRead,
          [criticalSection],
        ),
        returnValue: _i17.Future<T>.value(null),
      ) as _i17.Future<T>);
  @override
  _i17.Future<T> protectWrite<T>(_i17.Future<T> Function()? criticalSection) =>
      (super.noSuchMethod(
        Invocation.method(
          #protectWrite,
          [criticalSection],
        ),
        returnValue: _i17.Future<T>.value(null),
      ) as _i17.Future<T>);
}

/// A class which mocks [RepositoriesService].
///
/// See the documentation for Mockito's code generation for more information.
class MockRepositoriesService extends _i1.Mock
    implements _i10.RepositoriesService {
  MockRepositoriesService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i10.GitHub get github => (super.noSuchMethod(
        Invocation.getter(#github),
        returnValue: _FakeGitHub_12(
          this,
          Invocation.getter(#github),
        ),
      ) as _i10.GitHub);
  @override
  _i17.Stream<_i10.Repository> listRepositories({
    String? type = r'owner',
    String? sort = r'full_name',
    String? direction = r'asc',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listRepositories,
          [],
          {
            #type: type,
            #sort: sort,
            #direction: direction,
          },
        ),
        returnValue: _i17.Stream<_i10.Repository>.empty(),
      ) as _i17.Stream<_i10.Repository>);
  @override
  _i17.Stream<_i10.Repository> listUserRepositories(
    String? user, {
    String? type = r'owner',
    String? sort = r'full_name',
    String? direction = r'asc',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listUserRepositories,
          [user],
          {
            #type: type,
            #sort: sort,
            #direction: direction,
          },
        ),
        returnValue: _i17.Stream<_i10.Repository>.empty(),
      ) as _i17.Stream<_i10.Repository>);
  @override
  _i17.Stream<_i10.Repository> listOrganizationRepositories(
    String? org, {
    String? type = r'all',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listOrganizationRepositories,
          [org],
          {#type: type},
        ),
        returnValue: _i17.Stream<_i10.Repository>.empty(),
      ) as _i17.Stream<_i10.Repository>);
  @override
  _i17.Stream<_i10.Repository> listPublicRepositories({
    int? limit = 50,
    DateTime? since,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listPublicRepositories,
          [],
          {
            #limit: limit,
            #since: since,
          },
        ),
        returnValue: _i17.Stream<_i10.Repository>.empty(),
      ) as _i17.Stream<_i10.Repository>);
  @override
  _i17.Future<_i10.Repository> createRepository(
    _i10.CreateRepository? repository, {
    String? org,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #createRepository,
          [repository],
          {#org: org},
        ),
        returnValue: _i17.Future<_i10.Repository>.value(_FakeRepository_56(
          this,
          Invocation.method(
            #createRepository,
            [repository],
            {#org: org},
          ),
        )),
      ) as _i17.Future<_i10.Repository>);
  @override
  _i17.Future<_i10.LicenseDetails> getLicense(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #getLicense,
          [slug],
        ),
        returnValue:
            _i17.Future<_i10.LicenseDetails>.value(_FakeLicenseDetails_57(
          this,
          Invocation.method(
            #getLicense,
            [slug],
          ),
        )),
      ) as _i17.Future<_i10.LicenseDetails>);
  @override
  _i17.Future<_i10.Repository> getRepository(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #getRepository,
          [slug],
        ),
        returnValue: _i17.Future<_i10.Repository>.value(_FakeRepository_56(
          this,
          Invocation.method(
            #getRepository,
            [slug],
          ),
        )),
      ) as _i17.Future<_i10.Repository>);
  @override
  _i17.Stream<_i10.Repository> getRepositories(
          List<_i10.RepositorySlug>? slugs) =>
      (super.noSuchMethod(
        Invocation.method(
          #getRepositories,
          [slugs],
        ),
        returnValue: _i17.Stream<_i10.Repository>.empty(),
      ) as _i17.Stream<_i10.Repository>);
  @override
  _i17.Future<_i10.Repository> editRepository(
    _i10.RepositorySlug? slug, {
    String? name,
    String? description,
    String? homepage,
    bool? private,
    bool? hasIssues,
    bool? hasWiki,
    bool? hasDownloads,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #editRepository,
          [slug],
          {
            #name: name,
            #description: description,
            #homepage: homepage,
            #private: private,
            #hasIssues: hasIssues,
            #hasWiki: hasWiki,
            #hasDownloads: hasDownloads,
          },
        ),
        returnValue: _i17.Future<_i10.Repository>.value(_FakeRepository_56(
          this,
          Invocation.method(
            #editRepository,
            [slug],
            {
              #name: name,
              #description: description,
              #homepage: homepage,
              #private: private,
              #hasIssues: hasIssues,
              #hasWiki: hasWiki,
              #hasDownloads: hasDownloads,
            },
          ),
        )),
      ) as _i17.Future<_i10.Repository>);
  @override
  _i17.Future<bool> deleteRepository(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteRepository,
          [slug],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.Contributor> listContributors(
    _i10.RepositorySlug? slug, {
    bool? anon = false,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listContributors,
          [slug],
          {#anon: anon},
        ),
        returnValue: _i17.Stream<_i10.Contributor>.empty(),
      ) as _i17.Stream<_i10.Contributor>);
  @override
  _i17.Stream<_i10.Team> listTeams(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listTeams,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.Team>.empty(),
      ) as _i17.Stream<_i10.Team>);
  @override
  _i17.Future<_i10.LanguageBreakdown> listLanguages(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listLanguages,
          [slug],
        ),
        returnValue:
            _i17.Future<_i10.LanguageBreakdown>.value(_FakeLanguageBreakdown_58(
          this,
          Invocation.method(
            #listLanguages,
            [slug],
          ),
        )),
      ) as _i17.Future<_i10.LanguageBreakdown>);
  @override
  _i17.Stream<_i10.Tag> listTags(
    _i10.RepositorySlug? slug, {
    int? page = 1,
    int? pages,
    int? perPage = 30,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listTags,
          [slug],
          {
            #page: page,
            #pages: pages,
            #perPage: perPage,
          },
        ),
        returnValue: _i17.Stream<_i10.Tag>.empty(),
      ) as _i17.Stream<_i10.Tag>);
  @override
  _i17.Stream<_i10.Branch> listBranches(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listBranches,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.Branch>.empty(),
      ) as _i17.Stream<_i10.Branch>);
  @override
  _i17.Future<_i10.Branch> getBranch(
    _i10.RepositorySlug? slug,
    String? branch,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getBranch,
          [
            slug,
            branch,
          ],
        ),
        returnValue: _i17.Future<_i10.Branch>.value(_FakeBranch_59(
          this,
          Invocation.method(
            #getBranch,
            [
              slug,
              branch,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Branch>);
  @override
  _i17.Stream<_i10.Collaborator> listCollaborators(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCollaborators,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.Collaborator>.empty(),
      ) as _i17.Stream<_i10.Collaborator>);
  @override
  _i17.Future<bool> isCollaborator(
    _i10.RepositorySlug? slug,
    String? user,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #isCollaborator,
          [
            slug,
            user,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> addCollaborator(
    _i10.RepositorySlug? slug,
    String? user,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #addCollaborator,
          [
            slug,
            user,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> removeCollaborator(
    _i10.RepositorySlug? slug,
    String? user,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #removeCollaborator,
          [
            slug,
            user,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.CommitComment> listSingleCommitComments(
    _i10.RepositorySlug? slug,
    _i10.RepositoryCommit? commit,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listSingleCommitComments,
          [
            slug,
            commit,
          ],
        ),
        returnValue: _i17.Stream<_i10.CommitComment>.empty(),
      ) as _i17.Stream<_i10.CommitComment>);
  @override
  _i17.Stream<_i10.CommitComment> listCommitComments(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommitComments,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.CommitComment>.empty(),
      ) as _i17.Stream<_i10.CommitComment>);
  @override
  _i17.Future<_i10.CommitComment> createCommitComment(
    _i10.RepositorySlug? slug,
    _i10.RepositoryCommit? commit, {
    required String? body,
    String? path,
    int? position,
    int? line,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #createCommitComment,
          [
            slug,
            commit,
          ],
          {
            #body: body,
            #path: path,
            #position: position,
            #line: line,
          },
        ),
        returnValue:
            _i17.Future<_i10.CommitComment>.value(_FakeCommitComment_60(
          this,
          Invocation.method(
            #createCommitComment,
            [
              slug,
              commit,
            ],
            {
              #body: body,
              #path: path,
              #position: position,
              #line: line,
            },
          ),
        )),
      ) as _i17.Future<_i10.CommitComment>);
  @override
  _i17.Future<_i10.CommitComment> getCommitComment(
    _i10.RepositorySlug? slug, {
    required int? id,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getCommitComment,
          [slug],
          {#id: id},
        ),
        returnValue:
            _i17.Future<_i10.CommitComment>.value(_FakeCommitComment_60(
          this,
          Invocation.method(
            #getCommitComment,
            [slug],
            {#id: id},
          ),
        )),
      ) as _i17.Future<_i10.CommitComment>);
  @override
  _i17.Future<_i10.CommitComment> updateCommitComment(
    _i10.RepositorySlug? slug, {
    required int? id,
    required String? body,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #updateCommitComment,
          [slug],
          {
            #id: id,
            #body: body,
          },
        ),
        returnValue:
            _i17.Future<_i10.CommitComment>.value(_FakeCommitComment_60(
          this,
          Invocation.method(
            #updateCommitComment,
            [slug],
            {
              #id: id,
              #body: body,
            },
          ),
        )),
      ) as _i17.Future<_i10.CommitComment>);
  @override
  _i17.Future<bool> deleteCommitComment(
    _i10.RepositorySlug? slug, {
    required int? id,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteCommitComment,
          [slug],
          {#id: id},
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.RepositoryCommit> listCommits(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommits,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.RepositoryCommit>.empty(),
      ) as _i17.Stream<_i10.RepositoryCommit>);
  @override
  _i17.Future<_i10.RepositoryCommit> getCommit(
    _i10.RepositorySlug? slug,
    String? sha,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getCommit,
          [
            slug,
            sha,
          ],
        ),
        returnValue:
            _i17.Future<_i10.RepositoryCommit>.value(_FakeRepositoryCommit_61(
          this,
          Invocation.method(
            #getCommit,
            [
              slug,
              sha,
            ],
          ),
        )),
      ) as _i17.Future<_i10.RepositoryCommit>);
  @override
  _i17.Future<String> getCommitDiff(
    _i10.RepositorySlug? slug,
    String? sha,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getCommitDiff,
          [
            slug,
            sha,
          ],
        ),
        returnValue: _i17.Future<String>.value(''),
      ) as _i17.Future<String>);
  @override
  _i17.Future<_i10.GitHubComparison> compareCommits(
    _i10.RepositorySlug? slug,
    String? refBase,
    String? refHead,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #compareCommits,
          [
            slug,
            refBase,
            refHead,
          ],
        ),
        returnValue:
            _i17.Future<_i10.GitHubComparison>.value(_FakeGitHubComparison_62(
          this,
          Invocation.method(
            #compareCommits,
            [
              slug,
              refBase,
              refHead,
            ],
          ),
        )),
      ) as _i17.Future<_i10.GitHubComparison>);
  @override
  _i17.Future<_i10.GitHubFile> getReadme(
    _i10.RepositorySlug? slug, {
    String? ref,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getReadme,
          [slug],
          {#ref: ref},
        ),
        returnValue: _i17.Future<_i10.GitHubFile>.value(_FakeGitHubFile_63(
          this,
          Invocation.method(
            #getReadme,
            [slug],
            {#ref: ref},
          ),
        )),
      ) as _i17.Future<_i10.GitHubFile>);
  @override
  _i17.Future<_i10.RepositoryContents> getContents(
    _i10.RepositorySlug? slug,
    String? path, {
    String? ref,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getContents,
          [
            slug,
            path,
          ],
          {#ref: ref},
        ),
        returnValue: _i17.Future<_i10.RepositoryContents>.value(
            _FakeRepositoryContents_64(
          this,
          Invocation.method(
            #getContents,
            [
              slug,
              path,
            ],
            {#ref: ref},
          ),
        )),
      ) as _i17.Future<_i10.RepositoryContents>);
  @override
  _i17.Future<_i10.ContentCreation> createFile(
    _i10.RepositorySlug? slug,
    _i10.CreateFile? file,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createFile,
          [
            slug,
            file,
          ],
        ),
        returnValue:
            _i17.Future<_i10.ContentCreation>.value(_FakeContentCreation_65(
          this,
          Invocation.method(
            #createFile,
            [
              slug,
              file,
            ],
          ),
        )),
      ) as _i17.Future<_i10.ContentCreation>);
  @override
  _i17.Future<_i10.ContentCreation> updateFile(
    _i10.RepositorySlug? slug,
    String? path,
    String? message,
    String? content,
    String? sha, {
    String? branch,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #updateFile,
          [
            slug,
            path,
            message,
            content,
            sha,
          ],
          {#branch: branch},
        ),
        returnValue:
            _i17.Future<_i10.ContentCreation>.value(_FakeContentCreation_65(
          this,
          Invocation.method(
            #updateFile,
            [
              slug,
              path,
              message,
              content,
              sha,
            ],
            {#branch: branch},
          ),
        )),
      ) as _i17.Future<_i10.ContentCreation>);
  @override
  _i17.Future<_i10.ContentCreation> deleteFile(
    _i10.RepositorySlug? slug,
    String? path,
    String? message,
    String? sha,
    String? branch,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteFile,
          [
            slug,
            path,
            message,
            sha,
            branch,
          ],
        ),
        returnValue:
            _i17.Future<_i10.ContentCreation>.value(_FakeContentCreation_65(
          this,
          Invocation.method(
            #deleteFile,
            [
              slug,
              path,
              message,
              sha,
              branch,
            ],
          ),
        )),
      ) as _i17.Future<_i10.ContentCreation>);
  @override
  _i17.Future<String?> getArchiveLink(
    _i10.RepositorySlug? slug,
    String? ref, {
    String? format = r'tarball',
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getArchiveLink,
          [
            slug,
            ref,
          ],
          {#format: format},
        ),
        returnValue: _i17.Future<String?>.value(),
      ) as _i17.Future<String?>);
  @override
  _i17.Stream<_i10.Repository> listForks(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listForks,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.Repository>.empty(),
      ) as _i17.Stream<_i10.Repository>);
  @override
  _i17.Future<_i10.Repository> createFork(
    _i10.RepositorySlug? slug, [
    _i10.CreateFork? fork,
  ]) =>
      (super.noSuchMethod(
        Invocation.method(
          #createFork,
          [
            slug,
            fork,
          ],
        ),
        returnValue: _i17.Future<_i10.Repository>.value(_FakeRepository_56(
          this,
          Invocation.method(
            #createFork,
            [
              slug,
              fork,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Repository>);
  @override
  _i17.Stream<_i10.Hook> listHooks(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listHooks,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.Hook>.empty(),
      ) as _i17.Stream<_i10.Hook>);
  @override
  _i17.Future<_i10.Hook> getHook(
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getHook,
          [
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<_i10.Hook>.value(_FakeHook_66(
          this,
          Invocation.method(
            #getHook,
            [
              slug,
              id,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Hook>);
  @override
  _i17.Future<_i10.Hook> createHook(
    _i10.RepositorySlug? slug,
    _i10.CreateHook? hook,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createHook,
          [
            slug,
            hook,
          ],
        ),
        returnValue: _i17.Future<_i10.Hook>.value(_FakeHook_66(
          this,
          Invocation.method(
            #createHook,
            [
              slug,
              hook,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Hook>);
  @override
  _i17.Future<_i10.Hook> editHook(
    _i10.RepositorySlug? slug,
    _i10.Hook? hookToEdit, {
    String? configUrl,
    String? configContentType,
    String? configSecret,
    bool? configInsecureSsl,
    List<String>? events,
    List<String>? addEvents,
    List<String>? removeEvents,
    bool? active,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #editHook,
          [
            slug,
            hookToEdit,
          ],
          {
            #configUrl: configUrl,
            #configContentType: configContentType,
            #configSecret: configSecret,
            #configInsecureSsl: configInsecureSsl,
            #events: events,
            #addEvents: addEvents,
            #removeEvents: removeEvents,
            #active: active,
          },
        ),
        returnValue: _i17.Future<_i10.Hook>.value(_FakeHook_66(
          this,
          Invocation.method(
            #editHook,
            [
              slug,
              hookToEdit,
            ],
            {
              #configUrl: configUrl,
              #configContentType: configContentType,
              #configSecret: configSecret,
              #configInsecureSsl: configInsecureSsl,
              #events: events,
              #addEvents: addEvents,
              #removeEvents: removeEvents,
              #active: active,
            },
          ),
        )),
      ) as _i17.Future<_i10.Hook>);
  @override
  _i17.Future<bool> testPushHook(
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #testPushHook,
          [
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> pingHook(
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #pingHook,
          [
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> deleteHook(
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteHook,
          [
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.PublicKey> listDeployKeys(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listDeployKeys,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.PublicKey>.empty(),
      ) as _i17.Stream<_i10.PublicKey>);
  @override
  _i17.Future<_i10.PublicKey> getDeployKey(
    _i10.RepositorySlug? slug, {
    required int? id,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getDeployKey,
          [slug],
          {#id: id},
        ),
        returnValue: _i17.Future<_i10.PublicKey>.value(_FakePublicKey_67(
          this,
          Invocation.method(
            #getDeployKey,
            [slug],
            {#id: id},
          ),
        )),
      ) as _i17.Future<_i10.PublicKey>);
  @override
  _i17.Future<_i10.PublicKey> createDeployKey(
    _i10.RepositorySlug? slug,
    _i10.CreatePublicKey? key,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createDeployKey,
          [
            slug,
            key,
          ],
        ),
        returnValue: _i17.Future<_i10.PublicKey>.value(_FakePublicKey_67(
          this,
          Invocation.method(
            #createDeployKey,
            [
              slug,
              key,
            ],
          ),
        )),
      ) as _i17.Future<_i10.PublicKey>);
  @override
  _i17.Future<bool> deleteDeployKey({
    required _i10.RepositorySlug? slug,
    required _i10.PublicKey? key,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteDeployKey,
          [],
          {
            #slug: slug,
            #key: key,
          },
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<_i10.RepositoryCommit> merge(
    _i10.RepositorySlug? slug,
    _i10.CreateMerge? merge,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #merge,
          [
            slug,
            merge,
          ],
        ),
        returnValue:
            _i17.Future<_i10.RepositoryCommit>.value(_FakeRepositoryCommit_61(
          this,
          Invocation.method(
            #merge,
            [
              slug,
              merge,
            ],
          ),
        )),
      ) as _i17.Future<_i10.RepositoryCommit>);
  @override
  _i17.Future<_i10.RepositoryPages> getPagesInfo(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #getPagesInfo,
          [slug],
        ),
        returnValue:
            _i17.Future<_i10.RepositoryPages>.value(_FakeRepositoryPages_68(
          this,
          Invocation.method(
            #getPagesInfo,
            [slug],
          ),
        )),
      ) as _i17.Future<_i10.RepositoryPages>);
  @override
  _i17.Stream<_i10.PageBuild> listPagesBuilds(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listPagesBuilds,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.PageBuild>.empty(),
      ) as _i17.Stream<_i10.PageBuild>);
  @override
  _i17.Future<_i10.PageBuild> getLatestPagesBuild(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #getLatestPagesBuild,
          [slug],
        ),
        returnValue: _i17.Future<_i10.PageBuild>.value(_FakePageBuild_69(
          this,
          Invocation.method(
            #getLatestPagesBuild,
            [slug],
          ),
        )),
      ) as _i17.Future<_i10.PageBuild>);
  @override
  _i17.Stream<_i10.Release> listReleases(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listReleases,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.Release>.empty(),
      ) as _i17.Stream<_i10.Release>);
  @override
  _i17.Future<_i10.Release> getLatestRelease(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #getLatestRelease,
          [slug],
        ),
        returnValue: _i17.Future<_i10.Release>.value(_FakeRelease_70(
          this,
          Invocation.method(
            #getLatestRelease,
            [slug],
          ),
        )),
      ) as _i17.Future<_i10.Release>);
  @override
  _i17.Future<_i10.Release> getReleaseById(
    _i10.RepositorySlug? slug,
    int? id,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getReleaseById,
          [
            slug,
            id,
          ],
        ),
        returnValue: _i17.Future<_i10.Release>.value(_FakeRelease_70(
          this,
          Invocation.method(
            #getReleaseById,
            [
              slug,
              id,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Release>);
  @override
  _i17.Future<_i10.Release> getReleaseByTagName(
    _i10.RepositorySlug? slug,
    String? tagName,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getReleaseByTagName,
          [
            slug,
            tagName,
          ],
        ),
        returnValue: _i17.Future<_i10.Release>.value(_FakeRelease_70(
          this,
          Invocation.method(
            #getReleaseByTagName,
            [
              slug,
              tagName,
            ],
          ),
        )),
      ) as _i17.Future<_i10.Release>);
  @override
  _i17.Future<_i10.Release> createRelease(
    _i10.RepositorySlug? slug,
    _i10.CreateRelease? createRelease, {
    bool? getIfExists = true,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #createRelease,
          [
            slug,
            createRelease,
          ],
          {#getIfExists: getIfExists},
        ),
        returnValue: _i17.Future<_i10.Release>.value(_FakeRelease_70(
          this,
          Invocation.method(
            #createRelease,
            [
              slug,
              createRelease,
            ],
            {#getIfExists: getIfExists},
          ),
        )),
      ) as _i17.Future<_i10.Release>);
  @override
  _i17.Future<_i10.Release> editRelease(
    _i10.RepositorySlug? slug,
    _i10.Release? releaseToEdit, {
    String? tagName,
    String? targetCommitish,
    String? name,
    String? body,
    bool? draft,
    bool? preRelease,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #editRelease,
          [
            slug,
            releaseToEdit,
          ],
          {
            #tagName: tagName,
            #targetCommitish: targetCommitish,
            #name: name,
            #body: body,
            #draft: draft,
            #preRelease: preRelease,
          },
        ),
        returnValue: _i17.Future<_i10.Release>.value(_FakeRelease_70(
          this,
          Invocation.method(
            #editRelease,
            [
              slug,
              releaseToEdit,
            ],
            {
              #tagName: tagName,
              #targetCommitish: targetCommitish,
              #name: name,
              #body: body,
              #draft: draft,
              #preRelease: preRelease,
            },
          ),
        )),
      ) as _i17.Future<_i10.Release>);
  @override
  _i17.Future<bool> deleteRelease(
    _i10.RepositorySlug? slug,
    _i10.Release? release,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteRelease,
          [
            slug,
            release,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.ReleaseAsset> listReleaseAssets(
    _i10.RepositorySlug? slug,
    _i10.Release? release,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listReleaseAssets,
          [
            slug,
            release,
          ],
        ),
        returnValue: _i17.Stream<_i10.ReleaseAsset>.empty(),
      ) as _i17.Stream<_i10.ReleaseAsset>);
  @override
  _i17.Future<_i10.ReleaseAsset> getReleaseAsset(
    _i10.RepositorySlug? slug,
    _i10.Release? release, {
    required int? assetId,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getReleaseAsset,
          [
            slug,
            release,
          ],
          {#assetId: assetId},
        ),
        returnValue: _i17.Future<_i10.ReleaseAsset>.value(_FakeReleaseAsset_71(
          this,
          Invocation.method(
            #getReleaseAsset,
            [
              slug,
              release,
            ],
            {#assetId: assetId},
          ),
        )),
      ) as _i17.Future<_i10.ReleaseAsset>);
  @override
  _i17.Future<_i10.ReleaseAsset> editReleaseAsset(
    _i10.RepositorySlug? slug,
    _i10.ReleaseAsset? assetToEdit, {
    String? name,
    String? label,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #editReleaseAsset,
          [
            slug,
            assetToEdit,
          ],
          {
            #name: name,
            #label: label,
          },
        ),
        returnValue: _i17.Future<_i10.ReleaseAsset>.value(_FakeReleaseAsset_71(
          this,
          Invocation.method(
            #editReleaseAsset,
            [
              slug,
              assetToEdit,
            ],
            {
              #name: name,
              #label: label,
            },
          ),
        )),
      ) as _i17.Future<_i10.ReleaseAsset>);
  @override
  _i17.Future<bool> deleteReleaseAsset(
    _i10.RepositorySlug? slug,
    _i10.ReleaseAsset? asset,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #deleteReleaseAsset,
          [
            slug,
            asset,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<List<_i10.ReleaseAsset>> uploadReleaseAssets(
    _i10.Release? release,
    Iterable<_i10.CreateReleaseAsset>? createReleaseAssets,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #uploadReleaseAssets,
          [
            release,
            createReleaseAssets,
          ],
        ),
        returnValue:
            _i17.Future<List<_i10.ReleaseAsset>>.value(<_i10.ReleaseAsset>[]),
      ) as _i17.Future<List<_i10.ReleaseAsset>>);
  @override
  _i17.Future<List<_i10.ContributorStatistics>> listContributorStats(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listContributorStats,
          [slug],
        ),
        returnValue: _i17.Future<List<_i10.ContributorStatistics>>.value(
            <_i10.ContributorStatistics>[]),
      ) as _i17.Future<List<_i10.ContributorStatistics>>);
  @override
  _i17.Stream<_i10.YearCommitCountWeek> listCommitActivity(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCommitActivity,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.YearCommitCountWeek>.empty(),
      ) as _i17.Stream<_i10.YearCommitCountWeek>);
  @override
  _i17.Stream<_i10.WeeklyChangesCount> listCodeFrequency(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listCodeFrequency,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.WeeklyChangesCount>.empty(),
      ) as _i17.Stream<_i10.WeeklyChangesCount>);
  @override
  _i17.Future<_i10.ContributorParticipation> getParticipation(
          _i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #getParticipation,
          [slug],
        ),
        returnValue: _i17.Future<_i10.ContributorParticipation>.value(
            _FakeContributorParticipation_72(
          this,
          Invocation.method(
            #getParticipation,
            [slug],
          ),
        )),
      ) as _i17.Future<_i10.ContributorParticipation>);
  @override
  _i17.Stream<_i10.PunchcardEntry> listPunchcard(_i10.RepositorySlug? slug) =>
      (super.noSuchMethod(
        Invocation.method(
          #listPunchcard,
          [slug],
        ),
        returnValue: _i17.Stream<_i10.PunchcardEntry>.empty(),
      ) as _i17.Stream<_i10.PunchcardEntry>);
  @override
  _i17.Stream<_i10.RepositoryStatus> listStatuses(
    _i10.RepositorySlug? slug,
    String? ref,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #listStatuses,
          [
            slug,
            ref,
          ],
        ),
        returnValue: _i17.Stream<_i10.RepositoryStatus>.empty(),
      ) as _i17.Stream<_i10.RepositoryStatus>);
  @override
  _i17.Future<_i10.RepositoryStatus> createStatus(
    _i10.RepositorySlug? slug,
    String? ref,
    _i10.CreateStatus? request,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #createStatus,
          [
            slug,
            ref,
            request,
          ],
        ),
        returnValue:
            _i17.Future<_i10.RepositoryStatus>.value(_FakeRepositoryStatus_73(
          this,
          Invocation.method(
            #createStatus,
            [
              slug,
              ref,
              request,
            ],
          ),
        )),
      ) as _i17.Future<_i10.RepositoryStatus>);
  @override
  _i17.Future<_i10.CombinedRepositoryStatus> getCombinedStatus(
    _i10.RepositorySlug? slug,
    String? ref,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #getCombinedStatus,
          [
            slug,
            ref,
          ],
        ),
        returnValue: _i17.Future<_i10.CombinedRepositoryStatus>.value(
            _FakeCombinedRepositoryStatus_74(
          this,
          Invocation.method(
            #getCombinedStatus,
            [
              slug,
              ref,
            ],
          ),
        )),
      ) as _i17.Future<_i10.CombinedRepositoryStatus>);
  @override
  _i17.Future<_i10.ReleaseNotes> generateReleaseNotes(
          _i10.CreateReleaseNotes? crn) =>
      (super.noSuchMethod(
        Invocation.method(
          #generateReleaseNotes,
          [crn],
        ),
        returnValue: _i17.Future<_i10.ReleaseNotes>.value(_FakeReleaseNotes_75(
          this,
          Invocation.method(
            #generateReleaseNotes,
            [crn],
          ),
        )),
      ) as _i17.Future<_i10.ReleaseNotes>);
}

/// A class which mocks [TabledataResource].
///
/// See the documentation for Mockito's code generation for more information.
class MockTabledataResource extends _i1.Mock implements _i6.TabledataResource {
  MockTabledataResource() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i17.Future<_i6.TableDataInsertAllResponse> insertAll(
    _i6.TableDataInsertAllRequest? request,
    String? projectId,
    String? datasetId,
    String? tableId, {
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #insertAll,
          [
            request,
            projectId,
            datasetId,
            tableId,
          ],
          {#$fields: $fields},
        ),
        returnValue: _i17.Future<_i6.TableDataInsertAllResponse>.value(
            _FakeTableDataInsertAllResponse_76(
          this,
          Invocation.method(
            #insertAll,
            [
              request,
              projectId,
              datasetId,
              tableId,
            ],
            {#$fields: $fields},
          ),
        )),
      ) as _i17.Future<_i6.TableDataInsertAllResponse>);
  @override
  _i17.Future<_i6.TableDataList> list(
    String? projectId,
    String? datasetId,
    String? tableId, {
    int? maxResults,
    String? pageToken,
    String? selectedFields,
    String? startIndex,
    String? $fields,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #list,
          [
            projectId,
            datasetId,
            tableId,
          ],
          {
            #maxResults: maxResults,
            #pageToken: pageToken,
            #selectedFields: selectedFields,
            #startIndex: startIndex,
            #$fields: $fields,
          },
        ),
        returnValue: _i17.Future<_i6.TableDataList>.value(_FakeTableDataList_77(
          this,
          Invocation.method(
            #list,
            [
              projectId,
              datasetId,
              tableId,
            ],
            {
              #maxResults: maxResults,
              #pageToken: pageToken,
              #selectedFields: selectedFields,
              #startIndex: startIndex,
              #$fields: $fields,
            },
          ),
        )),
      ) as _i17.Future<_i6.TableDataList>);
}

/// A class which mocks [UsersService].
///
/// See the documentation for Mockito's code generation for more information.
class MockUsersService extends _i1.Mock implements _i10.UsersService {
  MockUsersService() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i10.GitHub get github => (super.noSuchMethod(
        Invocation.getter(#github),
        returnValue: _FakeGitHub_12(
          this,
          Invocation.getter(#github),
        ),
      ) as _i10.GitHub);
  @override
  _i17.Future<_i10.User> getUser(String? name) => (super.noSuchMethod(
        Invocation.method(
          #getUser,
          [name],
        ),
        returnValue: _i17.Future<_i10.User>.value(_FakeUser_78(
          this,
          Invocation.method(
            #getUser,
            [name],
          ),
        )),
      ) as _i17.Future<_i10.User>);
  @override
  _i17.Future<_i10.CurrentUser> editCurrentUser({
    String? name,
    String? email,
    String? blog,
    String? company,
    String? location,
    bool? hireable,
    String? bio,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #editCurrentUser,
          [],
          {
            #name: name,
            #email: email,
            #blog: blog,
            #company: company,
            #location: location,
            #hireable: hireable,
            #bio: bio,
          },
        ),
        returnValue: _i17.Future<_i10.CurrentUser>.value(_FakeCurrentUser_79(
          this,
          Invocation.method(
            #editCurrentUser,
            [],
            {
              #name: name,
              #email: email,
              #blog: blog,
              #company: company,
              #location: location,
              #hireable: hireable,
              #bio: bio,
            },
          ),
        )),
      ) as _i17.Future<_i10.CurrentUser>);
  @override
  _i17.Stream<_i10.User> getUsers(
    List<String>? names, {
    int? pages,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getUsers,
          [names],
          {#pages: pages},
        ),
        returnValue: _i17.Stream<_i10.User>.empty(),
      ) as _i17.Stream<_i10.User>);
  @override
  _i17.Future<_i10.CurrentUser> getCurrentUser() => (super.noSuchMethod(
        Invocation.method(
          #getCurrentUser,
          [],
        ),
        returnValue: _i17.Future<_i10.CurrentUser>.value(_FakeCurrentUser_79(
          this,
          Invocation.method(
            #getCurrentUser,
            [],
          ),
        )),
      ) as _i17.Future<_i10.CurrentUser>);
  @override
  _i17.Future<bool> isUser(String? name) => (super.noSuchMethod(
        Invocation.method(
          #isUser,
          [name],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.User> listUsers({
    int? pages,
    int? since,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #listUsers,
          [],
          {
            #pages: pages,
            #since: since,
          },
        ),
        returnValue: _i17.Stream<_i10.User>.empty(),
      ) as _i17.Stream<_i10.User>);
  @override
  _i17.Stream<_i10.UserEmail> listEmails() => (super.noSuchMethod(
        Invocation.method(
          #listEmails,
          [],
        ),
        returnValue: _i17.Stream<_i10.UserEmail>.empty(),
      ) as _i17.Stream<_i10.UserEmail>);
  @override
  _i17.Stream<_i10.UserEmail> addEmails(List<String>? emails) =>
      (super.noSuchMethod(
        Invocation.method(
          #addEmails,
          [emails],
        ),
        returnValue: _i17.Stream<_i10.UserEmail>.empty(),
      ) as _i17.Stream<_i10.UserEmail>);
  @override
  _i17.Future<bool> deleteEmails(List<String>? emails) => (super.noSuchMethod(
        Invocation.method(
          #deleteEmails,
          [emails],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.User> listUserFollowers(String? user) => (super.noSuchMethod(
        Invocation.method(
          #listUserFollowers,
          [user],
        ),
        returnValue: _i17.Stream<_i10.User>.empty(),
      ) as _i17.Stream<_i10.User>);
  @override
  _i17.Future<bool> isFollowingUser(String? user) => (super.noSuchMethod(
        Invocation.method(
          #isFollowingUser,
          [user],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> isUserFollowing(
    String? user,
    String? target,
  ) =>
      (super.noSuchMethod(
        Invocation.method(
          #isUserFollowing,
          [
            user,
            target,
          ],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> followUser(String? user) => (super.noSuchMethod(
        Invocation.method(
          #followUser,
          [user],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Future<bool> unfollowUser(String? user) => (super.noSuchMethod(
        Invocation.method(
          #unfollowUser,
          [user],
        ),
        returnValue: _i17.Future<bool>.value(false),
      ) as _i17.Future<bool>);
  @override
  _i17.Stream<_i10.User> listCurrentUserFollowers() => (super.noSuchMethod(
        Invocation.method(
          #listCurrentUserFollowers,
          [],
        ),
        returnValue: _i17.Stream<_i10.User>.empty(),
      ) as _i17.Stream<_i10.User>);
  @override
  _i17.Stream<_i10.User> listCurrentUserFollowing() => (super.noSuchMethod(
        Invocation.method(
          #listCurrentUserFollowing,
          [],
        ),
        returnValue: _i17.Stream<_i10.User>.empty(),
      ) as _i17.Stream<_i10.User>);
  @override
  _i17.Stream<_i10.PublicKey> listPublicKeys([String? userLogin]) =>
      (super.noSuchMethod(
        Invocation.method(
          #listPublicKeys,
          [userLogin],
        ),
        returnValue: _i17.Stream<_i10.PublicKey>.empty(),
      ) as _i17.Stream<_i10.PublicKey>);
  @override
  _i17.Future<_i10.PublicKey> createPublicKey(_i10.CreatePublicKey? key) =>
      (super.noSuchMethod(
        Invocation.method(
          #createPublicKey,
          [key],
        ),
        returnValue: _i17.Future<_i10.PublicKey>.value(_FakePublicKey_67(
          this,
          Invocation.method(
            #createPublicKey,
            [key],
          ),
        )),
      ) as _i17.Future<_i10.PublicKey>);
}

/// A class which mocks [Cache].
///
/// See the documentation for Mockito's code generation for more information.
class MockCache extends _i1.Mock implements _i20.Cache<_i27.Uint8List> {
  MockCache() {
    _i1.throwOnMissingStub(this);
  }

  @override
  _i20.Entry<_i27.Uint8List> operator [](String? key) => (super.noSuchMethod(
        Invocation.method(
          #[],
          [key],
        ),
        returnValue: _FakeEntry_80<_i27.Uint8List>(
          this,
          Invocation.method(
            #[],
            [key],
          ),
        ),
      ) as _i20.Entry<_i27.Uint8List>);
  @override
  _i20.Cache<_i27.Uint8List> withPrefix(String? prefix) => (super.noSuchMethod(
        Invocation.method(
          #withPrefix,
          [prefix],
        ),
        returnValue: _FakeCache_81<_i27.Uint8List>(
          this,
          Invocation.method(
            #withPrefix,
            [prefix],
          ),
        ),
      ) as _i20.Cache<_i27.Uint8List>);
  @override
  _i20.Cache<S> withCodec<S>(_i16.Codec<S, _i27.Uint8List>? codec) =>
      (super.noSuchMethod(
        Invocation.method(
          #withCodec,
          [codec],
        ),
        returnValue: _FakeCache_81<S>(
          this,
          Invocation.method(
            #withCodec,
            [codec],
          ),
        ),
      ) as _i20.Cache<S>);
  @override
  _i20.Cache<_i27.Uint8List> withTTL(Duration? ttl) => (super.noSuchMethod(
        Invocation.method(
          #withTTL,
          [ttl],
        ),
        returnValue: _FakeCache_81<_i27.Uint8List>(
          this,
          Invocation.method(
            #withTTL,
            [ttl],
          ),
        ),
      ) as _i20.Cache<_i27.Uint8List>);
}

/// A class which mocks [GitHub].
///
/// See the documentation for Mockito's code generation for more information.
class MockGitHub extends _i1.Mock implements _i10.GitHub {
  MockGitHub() {
    _i1.throwOnMissingStub(this);
  }

  @override
  set auth(_i10.Authentication? _auth) => super.noSuchMethod(
        Invocation.setter(
          #auth,
          _auth,
        ),
        returnValueForMissingStub: null,
      );
  @override
  String get endpoint => (super.noSuchMethod(
        Invocation.getter(#endpoint),
        returnValue: '',
      ) as String);
  @override
  String get version => (super.noSuchMethod(
        Invocation.getter(#version),
        returnValue: '',
      ) as String);
  @override
  _i2.Client get client => (super.noSuchMethod(
        Invocation.getter(#client),
        returnValue: _FakeClient_0(
          this,
          Invocation.getter(#client),
        ),
      ) as _i2.Client);
  @override
  _i10.ActivityService get activity => (super.noSuchMethod(
        Invocation.getter(#activity),
        returnValue: _FakeActivityService_82(
          this,
          Invocation.getter(#activity),
        ),
      ) as _i10.ActivityService);
  @override
  _i10.AuthorizationsService get authorizations => (super.noSuchMethod(
        Invocation.getter(#authorizations),
        returnValue: _FakeAuthorizationsService_83(
          this,
          Invocation.getter(#authorizations),
        ),
      ) as _i10.AuthorizationsService);
  @override
  _i10.GistsService get gists => (super.noSuchMethod(
        Invocation.getter(#gists),
        returnValue: _FakeGistsService_84(
          this,
          Invocation.getter(#gists),
        ),
      ) as _i10.GistsService);
  @override
  _i10.GitService get git => (super.noSuchMethod(
        Invocation.getter(#git),
        returnValue: _FakeGitService_85(
          this,
          Invocation.getter(#git),
        ),
      ) as _i10.GitService);
  @override
  _i10.IssuesService get issues => (super.noSuchMethod(
        Invocation.getter(#issues),
        returnValue: _FakeIssuesService_86(
          this,
          Invocation.getter(#issues),
        ),
      ) as _i10.IssuesService);
  @override
  _i10.MiscService get misc => (super.noSuchMethod(
        Invocation.getter(#misc),
        returnValue: _FakeMiscService_87(
          this,
          Invocation.getter(#misc),
        ),
      ) as _i10.MiscService);
  @override
  _i10.OrganizationsService get organizations => (super.noSuchMethod(
        Invocation.getter(#organizations),
        returnValue: _FakeOrganizationsService_88(
          this,
          Invocation.getter(#organizations),
        ),
      ) as _i10.OrganizationsService);
  @override
  _i10.PullRequestsService get pullRequests => (super.noSuchMethod(
        Invocation.getter(#pullRequests),
        returnValue: _FakePullRequestsService_89(
          this,
          Invocation.getter(#pullRequests),
        ),
      ) as _i10.PullRequestsService);
  @override
  _i10.RepositoriesService get repositories => (super.noSuchMethod(
        Invocation.getter(#repositories),
        returnValue: _FakeRepositoriesService_90(
          this,
          Invocation.getter(#repositories),
        ),
      ) as _i10.RepositoriesService);
  @override
  _i10.SearchService get search => (super.noSuchMethod(
        Invocation.getter(#search),
        returnValue: _FakeSearchService_91(
          this,
          Invocation.getter(#search),
        ),
      ) as _i10.SearchService);
  @override
  _i10.UrlShortenerService get urlShortener => (super.noSuchMethod(
        Invocation.getter(#urlShortener),
        returnValue: _FakeUrlShortenerService_92(
          this,
          Invocation.getter(#urlShortener),
        ),
      ) as _i10.UrlShortenerService);
  @override
  _i10.UsersService get users => (super.noSuchMethod(
        Invocation.getter(#users),
        returnValue: _FakeUsersService_93(
          this,
          Invocation.getter(#users),
        ),
      ) as _i10.UsersService);
  @override
  _i10.ChecksService get checks => (super.noSuchMethod(
        Invocation.getter(#checks),
        returnValue: _FakeChecksService_94(
          this,
          Invocation.getter(#checks),
        ),
      ) as _i10.ChecksService);
  @override
  _i17.Future<T> getJSON<S, T>(
    String? path, {
    int? statusCode,
    void Function(_i2.Response)? fail,
    Map<String, String>? headers,
    Map<String, String>? params,
    _i10.JSONConverter<S, T>? convert,
    String? preview,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #getJSON,
          [path],
          {
            #statusCode: statusCode,
            #fail: fail,
            #headers: headers,
            #params: params,
            #convert: convert,
            #preview: preview,
          },
        ),
        returnValue: _i17.Future<T>.value(null),
      ) as _i17.Future<T>);
  @override
  _i17.Future<T> postJSON<S, T>(
    String? path, {
    int? statusCode,
    void Function(_i2.Response)? fail,
    Map<String, String>? headers,
    Map<String, dynamic>? params,
    _i10.JSONConverter<S, T>? convert,
    dynamic body,
    String? preview,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #postJSON,
          [path],
          {
            #statusCode: statusCode,
            #fail: fail,
            #headers: headers,
            #params: params,
            #convert: convert,
            #body: body,
            #preview: preview,
          },
        ),
        returnValue: _i40.postJsonShim<S, T>(
          path,
          statusCode: statusCode,
          fail: fail,
          headers: headers,
          params: params,
          convert: convert,
          body: body,
          preview: preview,
        ),
      ) as _i17.Future<T>);
  @override
  _i17.Future<T> putJSON<S, T>(
    String? path, {
    int? statusCode,
    void Function(_i2.Response)? fail,
    Map<String, String>? headers,
    Map<String, dynamic>? params,
    _i10.JSONConverter<S, T>? convert,
    dynamic body,
    String? preview,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #putJSON,
          [path],
          {
            #statusCode: statusCode,
            #fail: fail,
            #headers: headers,
            #params: params,
            #convert: convert,
            #body: body,
            #preview: preview,
          },
        ),
        returnValue: _i17.Future<T>.value(null),
      ) as _i17.Future<T>);
  @override
  _i17.Future<T> patchJSON<S, T>(
    String? path, {
    int? statusCode,
    void Function(_i2.Response)? fail,
    Map<String, String>? headers,
    Map<String, dynamic>? params,
    _i10.JSONConverter<S, T>? convert,
    dynamic body,
    String? preview,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #patchJSON,
          [path],
          {
            #statusCode: statusCode,
            #fail: fail,
            #headers: headers,
            #params: params,
            #convert: convert,
            #body: body,
            #preview: preview,
          },
        ),
        returnValue: _i17.Future<T>.value(null),
      ) as _i17.Future<T>);
  @override
  _i17.Future<T> requestJson<S, T>(
    String? method,
    String? path, {
    int? statusCode,
    void Function(_i2.Response)? fail,
    Map<String, String>? headers,
    Map<String, dynamic>? params,
    _i10.JSONConverter<S, T?>? convert,
    dynamic body,
    String? preview,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #requestJson,
          [
            method,
            path,
          ],
          {
            #statusCode: statusCode,
            #fail: fail,
            #headers: headers,
            #params: params,
            #convert: convert,
            #body: body,
            #preview: preview,
          },
        ),
        returnValue: _i17.Future<T>.value(null),
      ) as _i17.Future<T>);
  @override
  _i17.Future<_i2.Response> request(
    String? method,
    String? path, {
    Map<String, String>? headers,
    Map<String, dynamic>? params,
    dynamic body,
    int? statusCode,
    void Function(_i2.Response)? fail,
    String? preview,
  }) =>
      (super.noSuchMethod(
        Invocation.method(
          #request,
          [
            method,
            path,
          ],
          {
            #headers: headers,
            #params: params,
            #body: body,
            #statusCode: statusCode,
            #fail: fail,
            #preview: preview,
          },
        ),
        returnValue: _i17.Future<_i2.Response>.value(_FakeResponse_95(
          this,
          Invocation.method(
            #request,
            [
              method,
              path,
            ],
            {
              #headers: headers,
              #params: params,
              #body: body,
              #statusCode: statusCode,
              #fail: fail,
              #preview: preview,
            },
          ),
        )),
      ) as _i17.Future<_i2.Response>);
  @override
  void handleStatusCode(_i2.Response? response) => super.noSuchMethod(
        Invocation.method(
          #handleStatusCode,
          [response],
        ),
        returnValueForMissingStub: null,
      );
  @override
  void dispose() => super.noSuchMethod(
        Invocation.method(
          #dispose,
          [],
        ),
        returnValueForMissingStub: null,
      );
}
