git-touch-android-ios-app/lib/graphql/schema.schema.gql.g.dart

// GENERATED CODE - DO NOT MODIFY BY HAND

part of 'schema.schema.gql.dart';

// **************************************************************************
// BuiltValueGenerator
// **************************************************************************

const GAuditLogOrderField _$gAuditLogOrderFieldCREATED_AT =
    const GAuditLogOrderField._('CREATED_AT');

GAuditLogOrderField _$gAuditLogOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gAuditLogOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GAuditLogOrderField> _$gAuditLogOrderFieldValues =
    new BuiltSet<GAuditLogOrderField>(const <GAuditLogOrderField>[
  _$gAuditLogOrderFieldCREATED_AT,
]);

const GCheckAnnotationLevel _$gCheckAnnotationLevelFAILURE =
    const GCheckAnnotationLevel._('FAILURE');
const GCheckAnnotationLevel _$gCheckAnnotationLevelNOTICE =
    const GCheckAnnotationLevel._('NOTICE');
const GCheckAnnotationLevel _$gCheckAnnotationLevelWARNING =
    const GCheckAnnotationLevel._('WARNING');

GCheckAnnotationLevel _$gCheckAnnotationLevelValueOf(String name) {
  switch (name) {
    case 'FAILURE':
      return _$gCheckAnnotationLevelFAILURE;
    case 'NOTICE':
      return _$gCheckAnnotationLevelNOTICE;
    case 'WARNING':
      return _$gCheckAnnotationLevelWARNING;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCheckAnnotationLevel> _$gCheckAnnotationLevelValues =
    new BuiltSet<GCheckAnnotationLevel>(const <GCheckAnnotationLevel>[
  _$gCheckAnnotationLevelFAILURE,
  _$gCheckAnnotationLevelNOTICE,
  _$gCheckAnnotationLevelWARNING,
]);

const GCheckConclusionState _$gCheckConclusionStateACTION_REQUIRED =
    const GCheckConclusionState._('ACTION_REQUIRED');
const GCheckConclusionState _$gCheckConclusionStateCANCELLED =
    const GCheckConclusionState._('CANCELLED');
const GCheckConclusionState _$gCheckConclusionStateFAILURE =
    const GCheckConclusionState._('FAILURE');
const GCheckConclusionState _$gCheckConclusionStateNEUTRAL =
    const GCheckConclusionState._('NEUTRAL');
const GCheckConclusionState _$gCheckConclusionStateSKIPPED =
    const GCheckConclusionState._('SKIPPED');
const GCheckConclusionState _$gCheckConclusionStateSTALE =
    const GCheckConclusionState._('STALE');
const GCheckConclusionState _$gCheckConclusionStateSTARTUP_FAILURE =
    const GCheckConclusionState._('STARTUP_FAILURE');
const GCheckConclusionState _$gCheckConclusionStateSUCCESS =
    const GCheckConclusionState._('SUCCESS');
const GCheckConclusionState _$gCheckConclusionStateTIMED_OUT =
    const GCheckConclusionState._('TIMED_OUT');

GCheckConclusionState _$gCheckConclusionStateValueOf(String name) {
  switch (name) {
    case 'ACTION_REQUIRED':
      return _$gCheckConclusionStateACTION_REQUIRED;
    case 'CANCELLED':
      return _$gCheckConclusionStateCANCELLED;
    case 'FAILURE':
      return _$gCheckConclusionStateFAILURE;
    case 'NEUTRAL':
      return _$gCheckConclusionStateNEUTRAL;
    case 'SKIPPED':
      return _$gCheckConclusionStateSKIPPED;
    case 'STALE':
      return _$gCheckConclusionStateSTALE;
    case 'STARTUP_FAILURE':
      return _$gCheckConclusionStateSTARTUP_FAILURE;
    case 'SUCCESS':
      return _$gCheckConclusionStateSUCCESS;
    case 'TIMED_OUT':
      return _$gCheckConclusionStateTIMED_OUT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCheckConclusionState> _$gCheckConclusionStateValues =
    new BuiltSet<GCheckConclusionState>(const <GCheckConclusionState>[
  _$gCheckConclusionStateACTION_REQUIRED,
  _$gCheckConclusionStateCANCELLED,
  _$gCheckConclusionStateFAILURE,
  _$gCheckConclusionStateNEUTRAL,
  _$gCheckConclusionStateSKIPPED,
  _$gCheckConclusionStateSTALE,
  _$gCheckConclusionStateSTARTUP_FAILURE,
  _$gCheckConclusionStateSUCCESS,
  _$gCheckConclusionStateTIMED_OUT,
]);

const GCheckRunType _$gCheckRunTypeALL = const GCheckRunType._('ALL');
const GCheckRunType _$gCheckRunTypeLATEST = const GCheckRunType._('LATEST');

GCheckRunType _$gCheckRunTypeValueOf(String name) {
  switch (name) {
    case 'ALL':
      return _$gCheckRunTypeALL;
    case 'LATEST':
      return _$gCheckRunTypeLATEST;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCheckRunType> _$gCheckRunTypeValues =
    new BuiltSet<GCheckRunType>(const <GCheckRunType>[
  _$gCheckRunTypeALL,
  _$gCheckRunTypeLATEST,
]);

const GCheckStatusState _$gCheckStatusStateCOMPLETED =
    const GCheckStatusState._('COMPLETED');
const GCheckStatusState _$gCheckStatusStateIN_PROGRESS =
    const GCheckStatusState._('IN_PROGRESS');
const GCheckStatusState _$gCheckStatusStatePENDING =
    const GCheckStatusState._('PENDING');
const GCheckStatusState _$gCheckStatusStateQUEUED =
    const GCheckStatusState._('QUEUED');
const GCheckStatusState _$gCheckStatusStateREQUESTED =
    const GCheckStatusState._('REQUESTED');
const GCheckStatusState _$gCheckStatusStateWAITING =
    const GCheckStatusState._('WAITING');

GCheckStatusState _$gCheckStatusStateValueOf(String name) {
  switch (name) {
    case 'COMPLETED':
      return _$gCheckStatusStateCOMPLETED;
    case 'IN_PROGRESS':
      return _$gCheckStatusStateIN_PROGRESS;
    case 'PENDING':
      return _$gCheckStatusStatePENDING;
    case 'QUEUED':
      return _$gCheckStatusStateQUEUED;
    case 'REQUESTED':
      return _$gCheckStatusStateREQUESTED;
    case 'WAITING':
      return _$gCheckStatusStateWAITING;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCheckStatusState> _$gCheckStatusStateValues =
    new BuiltSet<GCheckStatusState>(const <GCheckStatusState>[
  _$gCheckStatusStateCOMPLETED,
  _$gCheckStatusStateIN_PROGRESS,
  _$gCheckStatusStatePENDING,
  _$gCheckStatusStateQUEUED,
  _$gCheckStatusStateREQUESTED,
  _$gCheckStatusStateWAITING,
]);

const GCollaboratorAffiliation _$gCollaboratorAffiliationALL =
    const GCollaboratorAffiliation._('ALL');
const GCollaboratorAffiliation _$gCollaboratorAffiliationDIRECT =
    const GCollaboratorAffiliation._('DIRECT');
const GCollaboratorAffiliation _$gCollaboratorAffiliationOUTSIDE =
    const GCollaboratorAffiliation._('OUTSIDE');

GCollaboratorAffiliation _$gCollaboratorAffiliationValueOf(String name) {
  switch (name) {
    case 'ALL':
      return _$gCollaboratorAffiliationALL;
    case 'DIRECT':
      return _$gCollaboratorAffiliationDIRECT;
    case 'OUTSIDE':
      return _$gCollaboratorAffiliationOUTSIDE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCollaboratorAffiliation> _$gCollaboratorAffiliationValues =
    new BuiltSet<GCollaboratorAffiliation>(const <GCollaboratorAffiliation>[
  _$gCollaboratorAffiliationALL,
  _$gCollaboratorAffiliationDIRECT,
  _$gCollaboratorAffiliationOUTSIDE,
]);

const GCommentAuthorAssociation _$gCommentAuthorAssociationCOLLABORATOR =
    const GCommentAuthorAssociation._('COLLABORATOR');
const GCommentAuthorAssociation _$gCommentAuthorAssociationCONTRIBUTOR =
    const GCommentAuthorAssociation._('CONTRIBUTOR');
const GCommentAuthorAssociation _$gCommentAuthorAssociationFIRST_TIMER =
    const GCommentAuthorAssociation._('FIRST_TIMER');
const GCommentAuthorAssociation
    _$gCommentAuthorAssociationFIRST_TIME_CONTRIBUTOR =
    const GCommentAuthorAssociation._('FIRST_TIME_CONTRIBUTOR');
const GCommentAuthorAssociation _$gCommentAuthorAssociationMANNEQUIN =
    const GCommentAuthorAssociation._('MANNEQUIN');
const GCommentAuthorAssociation _$gCommentAuthorAssociationMEMBER =
    const GCommentAuthorAssociation._('MEMBER');
const GCommentAuthorAssociation _$gCommentAuthorAssociationNONE =
    const GCommentAuthorAssociation._('NONE');
const GCommentAuthorAssociation _$gCommentAuthorAssociationOWNER =
    const GCommentAuthorAssociation._('OWNER');

GCommentAuthorAssociation _$gCommentAuthorAssociationValueOf(String name) {
  switch (name) {
    case 'COLLABORATOR':
      return _$gCommentAuthorAssociationCOLLABORATOR;
    case 'CONTRIBUTOR':
      return _$gCommentAuthorAssociationCONTRIBUTOR;
    case 'FIRST_TIMER':
      return _$gCommentAuthorAssociationFIRST_TIMER;
    case 'FIRST_TIME_CONTRIBUTOR':
      return _$gCommentAuthorAssociationFIRST_TIME_CONTRIBUTOR;
    case 'MANNEQUIN':
      return _$gCommentAuthorAssociationMANNEQUIN;
    case 'MEMBER':
      return _$gCommentAuthorAssociationMEMBER;
    case 'NONE':
      return _$gCommentAuthorAssociationNONE;
    case 'OWNER':
      return _$gCommentAuthorAssociationOWNER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCommentAuthorAssociation> _$gCommentAuthorAssociationValues =
    new BuiltSet<GCommentAuthorAssociation>(const <GCommentAuthorAssociation>[
  _$gCommentAuthorAssociationCOLLABORATOR,
  _$gCommentAuthorAssociationCONTRIBUTOR,
  _$gCommentAuthorAssociationFIRST_TIMER,
  _$gCommentAuthorAssociationFIRST_TIME_CONTRIBUTOR,
  _$gCommentAuthorAssociationMANNEQUIN,
  _$gCommentAuthorAssociationMEMBER,
  _$gCommentAuthorAssociationNONE,
  _$gCommentAuthorAssociationOWNER,
]);

const GCommentCannotUpdateReason _$gCommentCannotUpdateReasonARCHIVED =
    const GCommentCannotUpdateReason._('ARCHIVED');
const GCommentCannotUpdateReason _$gCommentCannotUpdateReasonDENIED =
    const GCommentCannotUpdateReason._('DENIED');
const GCommentCannotUpdateReason
    _$gCommentCannotUpdateReasonINSUFFICIENT_ACCESS =
    const GCommentCannotUpdateReason._('INSUFFICIENT_ACCESS');
const GCommentCannotUpdateReason _$gCommentCannotUpdateReasonLOCKED =
    const GCommentCannotUpdateReason._('LOCKED');
const GCommentCannotUpdateReason _$gCommentCannotUpdateReasonLOGIN_REQUIRED =
    const GCommentCannotUpdateReason._('LOGIN_REQUIRED');
const GCommentCannotUpdateReason _$gCommentCannotUpdateReasonMAINTENANCE =
    const GCommentCannotUpdateReason._('MAINTENANCE');
const GCommentCannotUpdateReason
    _$gCommentCannotUpdateReasonVERIFIED_EMAIL_REQUIRED =
    const GCommentCannotUpdateReason._('VERIFIED_EMAIL_REQUIRED');

GCommentCannotUpdateReason _$gCommentCannotUpdateReasonValueOf(String name) {
  switch (name) {
    case 'ARCHIVED':
      return _$gCommentCannotUpdateReasonARCHIVED;
    case 'DENIED':
      return _$gCommentCannotUpdateReasonDENIED;
    case 'INSUFFICIENT_ACCESS':
      return _$gCommentCannotUpdateReasonINSUFFICIENT_ACCESS;
    case 'LOCKED':
      return _$gCommentCannotUpdateReasonLOCKED;
    case 'LOGIN_REQUIRED':
      return _$gCommentCannotUpdateReasonLOGIN_REQUIRED;
    case 'MAINTENANCE':
      return _$gCommentCannotUpdateReasonMAINTENANCE;
    case 'VERIFIED_EMAIL_REQUIRED':
      return _$gCommentCannotUpdateReasonVERIFIED_EMAIL_REQUIRED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCommentCannotUpdateReason> _$gCommentCannotUpdateReasonValues =
    new BuiltSet<GCommentCannotUpdateReason>(const <GCommentCannotUpdateReason>[
  _$gCommentCannotUpdateReasonARCHIVED,
  _$gCommentCannotUpdateReasonDENIED,
  _$gCommentCannotUpdateReasonINSUFFICIENT_ACCESS,
  _$gCommentCannotUpdateReasonLOCKED,
  _$gCommentCannotUpdateReasonLOGIN_REQUIRED,
  _$gCommentCannotUpdateReasonMAINTENANCE,
  _$gCommentCannotUpdateReasonVERIFIED_EMAIL_REQUIRED,
]);

const GCommitContributionOrderField
    _$gCommitContributionOrderFieldCOMMIT_COUNT =
    const GCommitContributionOrderField._('COMMIT_COUNT');
const GCommitContributionOrderField _$gCommitContributionOrderFieldOCCURRED_AT =
    const GCommitContributionOrderField._('OCCURRED_AT');

GCommitContributionOrderField _$gCommitContributionOrderFieldValueOf(
    String name) {
  switch (name) {
    case 'COMMIT_COUNT':
      return _$gCommitContributionOrderFieldCOMMIT_COUNT;
    case 'OCCURRED_AT':
      return _$gCommitContributionOrderFieldOCCURRED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GCommitContributionOrderField>
    _$gCommitContributionOrderFieldValues = new BuiltSet<
        GCommitContributionOrderField>(const <GCommitContributionOrderField>[
  _$gCommitContributionOrderFieldCOMMIT_COUNT,
  _$gCommitContributionOrderFieldOCCURRED_AT,
]);

const GContributionLevel _$gContributionLevelFIRST_QUARTILE =
    const GContributionLevel._('FIRST_QUARTILE');
const GContributionLevel _$gContributionLevelFOURTH_QUARTILE =
    const GContributionLevel._('FOURTH_QUARTILE');
const GContributionLevel _$gContributionLevelNONE =
    const GContributionLevel._('NONE');
const GContributionLevel _$gContributionLevelSECOND_QUARTILE =
    const GContributionLevel._('SECOND_QUARTILE');
const GContributionLevel _$gContributionLevelTHIRD_QUARTILE =
    const GContributionLevel._('THIRD_QUARTILE');

GContributionLevel _$gContributionLevelValueOf(String name) {
  switch (name) {
    case 'FIRST_QUARTILE':
      return _$gContributionLevelFIRST_QUARTILE;
    case 'FOURTH_QUARTILE':
      return _$gContributionLevelFOURTH_QUARTILE;
    case 'NONE':
      return _$gContributionLevelNONE;
    case 'SECOND_QUARTILE':
      return _$gContributionLevelSECOND_QUARTILE;
    case 'THIRD_QUARTILE':
      return _$gContributionLevelTHIRD_QUARTILE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GContributionLevel> _$gContributionLevelValues =
    new BuiltSet<GContributionLevel>(const <GContributionLevel>[
  _$gContributionLevelFIRST_QUARTILE,
  _$gContributionLevelFOURTH_QUARTILE,
  _$gContributionLevelNONE,
  _$gContributionLevelSECOND_QUARTILE,
  _$gContributionLevelTHIRD_QUARTILE,
]);

const GDefaultRepositoryPermissionField
    _$gDefaultRepositoryPermissionFieldADMIN =
    const GDefaultRepositoryPermissionField._('ADMIN');
const GDefaultRepositoryPermissionField
    _$gDefaultRepositoryPermissionFieldNONE =
    const GDefaultRepositoryPermissionField._('NONE');
const GDefaultRepositoryPermissionField
    _$gDefaultRepositoryPermissionFieldREAD =
    const GDefaultRepositoryPermissionField._('READ');
const GDefaultRepositoryPermissionField
    _$gDefaultRepositoryPermissionFieldWRITE =
    const GDefaultRepositoryPermissionField._('WRITE');

GDefaultRepositoryPermissionField _$gDefaultRepositoryPermissionFieldValueOf(
    String name) {
  switch (name) {
    case 'ADMIN':
      return _$gDefaultRepositoryPermissionFieldADMIN;
    case 'NONE':
      return _$gDefaultRepositoryPermissionFieldNONE;
    case 'READ':
      return _$gDefaultRepositoryPermissionFieldREAD;
    case 'WRITE':
      return _$gDefaultRepositoryPermissionFieldWRITE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDefaultRepositoryPermissionField>
    _$gDefaultRepositoryPermissionFieldValues =
    new BuiltSet<GDefaultRepositoryPermissionField>(const <
        GDefaultRepositoryPermissionField>[
  _$gDefaultRepositoryPermissionFieldADMIN,
  _$gDefaultRepositoryPermissionFieldNONE,
  _$gDefaultRepositoryPermissionFieldREAD,
  _$gDefaultRepositoryPermissionFieldWRITE,
]);

const GDeploymentOrderField _$gDeploymentOrderFieldCREATED_AT =
    const GDeploymentOrderField._('CREATED_AT');

GDeploymentOrderField _$gDeploymentOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gDeploymentOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDeploymentOrderField> _$gDeploymentOrderFieldValues =
    new BuiltSet<GDeploymentOrderField>(const <GDeploymentOrderField>[
  _$gDeploymentOrderFieldCREATED_AT,
]);

const GDeploymentProtectionRuleType
    _$gDeploymentProtectionRuleTypeREQUIRED_REVIEWERS =
    const GDeploymentProtectionRuleType._('REQUIRED_REVIEWERS');
const GDeploymentProtectionRuleType _$gDeploymentProtectionRuleTypeWAIT_TIMER =
    const GDeploymentProtectionRuleType._('WAIT_TIMER');

GDeploymentProtectionRuleType _$gDeploymentProtectionRuleTypeValueOf(
    String name) {
  switch (name) {
    case 'REQUIRED_REVIEWERS':
      return _$gDeploymentProtectionRuleTypeREQUIRED_REVIEWERS;
    case 'WAIT_TIMER':
      return _$gDeploymentProtectionRuleTypeWAIT_TIMER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDeploymentProtectionRuleType>
    _$gDeploymentProtectionRuleTypeValues = new BuiltSet<
        GDeploymentProtectionRuleType>(const <GDeploymentProtectionRuleType>[
  _$gDeploymentProtectionRuleTypeREQUIRED_REVIEWERS,
  _$gDeploymentProtectionRuleTypeWAIT_TIMER,
]);

const GDeploymentReviewState _$gDeploymentReviewStateAPPROVED =
    const GDeploymentReviewState._('APPROVED');
const GDeploymentReviewState _$gDeploymentReviewStateREJECTED =
    const GDeploymentReviewState._('REJECTED');

GDeploymentReviewState _$gDeploymentReviewStateValueOf(String name) {
  switch (name) {
    case 'APPROVED':
      return _$gDeploymentReviewStateAPPROVED;
    case 'REJECTED':
      return _$gDeploymentReviewStateREJECTED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDeploymentReviewState> _$gDeploymentReviewStateValues =
    new BuiltSet<GDeploymentReviewState>(const <GDeploymentReviewState>[
  _$gDeploymentReviewStateAPPROVED,
  _$gDeploymentReviewStateREJECTED,
]);

const GDeploymentState _$gDeploymentStateABANDONED =
    const GDeploymentState._('ABANDONED');
const GDeploymentState _$gDeploymentStateACTIVE =
    const GDeploymentState._('ACTIVE');
const GDeploymentState _$gDeploymentStateDESTROYED =
    const GDeploymentState._('DESTROYED');
const GDeploymentState _$gDeploymentStateERROR =
    const GDeploymentState._('ERROR');
const GDeploymentState _$gDeploymentStateFAILURE =
    const GDeploymentState._('FAILURE');
const GDeploymentState _$gDeploymentStateINACTIVE =
    const GDeploymentState._('INACTIVE');
const GDeploymentState _$gDeploymentStateIN_PROGRESS =
    const GDeploymentState._('IN_PROGRESS');
const GDeploymentState _$gDeploymentStatePENDING =
    const GDeploymentState._('PENDING');
const GDeploymentState _$gDeploymentStateQUEUED =
    const GDeploymentState._('QUEUED');
const GDeploymentState _$gDeploymentStateWAITING =
    const GDeploymentState._('WAITING');

GDeploymentState _$gDeploymentStateValueOf(String name) {
  switch (name) {
    case 'ABANDONED':
      return _$gDeploymentStateABANDONED;
    case 'ACTIVE':
      return _$gDeploymentStateACTIVE;
    case 'DESTROYED':
      return _$gDeploymentStateDESTROYED;
    case 'ERROR':
      return _$gDeploymentStateERROR;
    case 'FAILURE':
      return _$gDeploymentStateFAILURE;
    case 'INACTIVE':
      return _$gDeploymentStateINACTIVE;
    case 'IN_PROGRESS':
      return _$gDeploymentStateIN_PROGRESS;
    case 'PENDING':
      return _$gDeploymentStatePENDING;
    case 'QUEUED':
      return _$gDeploymentStateQUEUED;
    case 'WAITING':
      return _$gDeploymentStateWAITING;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDeploymentState> _$gDeploymentStateValues =
    new BuiltSet<GDeploymentState>(const <GDeploymentState>[
  _$gDeploymentStateABANDONED,
  _$gDeploymentStateACTIVE,
  _$gDeploymentStateDESTROYED,
  _$gDeploymentStateERROR,
  _$gDeploymentStateFAILURE,
  _$gDeploymentStateINACTIVE,
  _$gDeploymentStateIN_PROGRESS,
  _$gDeploymentStatePENDING,
  _$gDeploymentStateQUEUED,
  _$gDeploymentStateWAITING,
]);

const GDeploymentStatusState _$gDeploymentStatusStateERROR =
    const GDeploymentStatusState._('ERROR');
const GDeploymentStatusState _$gDeploymentStatusStateFAILURE =
    const GDeploymentStatusState._('FAILURE');
const GDeploymentStatusState _$gDeploymentStatusStateINACTIVE =
    const GDeploymentStatusState._('INACTIVE');
const GDeploymentStatusState _$gDeploymentStatusStateIN_PROGRESS =
    const GDeploymentStatusState._('IN_PROGRESS');
const GDeploymentStatusState _$gDeploymentStatusStatePENDING =
    const GDeploymentStatusState._('PENDING');
const GDeploymentStatusState _$gDeploymentStatusStateQUEUED =
    const GDeploymentStatusState._('QUEUED');
const GDeploymentStatusState _$gDeploymentStatusStateSUCCESS =
    const GDeploymentStatusState._('SUCCESS');
const GDeploymentStatusState _$gDeploymentStatusStateWAITING =
    const GDeploymentStatusState._('WAITING');

GDeploymentStatusState _$gDeploymentStatusStateValueOf(String name) {
  switch (name) {
    case 'ERROR':
      return _$gDeploymentStatusStateERROR;
    case 'FAILURE':
      return _$gDeploymentStatusStateFAILURE;
    case 'INACTIVE':
      return _$gDeploymentStatusStateINACTIVE;
    case 'IN_PROGRESS':
      return _$gDeploymentStatusStateIN_PROGRESS;
    case 'PENDING':
      return _$gDeploymentStatusStatePENDING;
    case 'QUEUED':
      return _$gDeploymentStatusStateQUEUED;
    case 'SUCCESS':
      return _$gDeploymentStatusStateSUCCESS;
    case 'WAITING':
      return _$gDeploymentStatusStateWAITING;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDeploymentStatusState> _$gDeploymentStatusStateValues =
    new BuiltSet<GDeploymentStatusState>(const <GDeploymentStatusState>[
  _$gDeploymentStatusStateERROR,
  _$gDeploymentStatusStateFAILURE,
  _$gDeploymentStatusStateINACTIVE,
  _$gDeploymentStatusStateIN_PROGRESS,
  _$gDeploymentStatusStatePENDING,
  _$gDeploymentStatusStateQUEUED,
  _$gDeploymentStatusStateSUCCESS,
  _$gDeploymentStatusStateWAITING,
]);

const GDiffSide _$gDiffSideLEFT = const GDiffSide._('LEFT');
const GDiffSide _$gDiffSideRIGHT = const GDiffSide._('RIGHT');

GDiffSide _$gDiffSideValueOf(String name) {
  switch (name) {
    case 'LEFT':
      return _$gDiffSideLEFT;
    case 'RIGHT':
      return _$gDiffSideRIGHT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDiffSide> _$gDiffSideValues =
    new BuiltSet<GDiffSide>(const <GDiffSide>[
  _$gDiffSideLEFT,
  _$gDiffSideRIGHT,
]);

const GDiscussionOrderField _$gDiscussionOrderFieldCREATED_AT =
    const GDiscussionOrderField._('CREATED_AT');
const GDiscussionOrderField _$gDiscussionOrderFieldUPDATED_AT =
    const GDiscussionOrderField._('UPDATED_AT');

GDiscussionOrderField _$gDiscussionOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gDiscussionOrderFieldCREATED_AT;
    case 'UPDATED_AT':
      return _$gDiscussionOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GDiscussionOrderField> _$gDiscussionOrderFieldValues =
    new BuiltSet<GDiscussionOrderField>(const <GDiscussionOrderField>[
  _$gDiscussionOrderFieldCREATED_AT,
  _$gDiscussionOrderFieldUPDATED_AT,
]);

const GEnterpriseAdministratorInvitationOrderField
    _$gEnterpriseAdministratorInvitationOrderFieldCREATED_AT =
    const GEnterpriseAdministratorInvitationOrderField._('CREATED_AT');

GEnterpriseAdministratorInvitationOrderField
    _$gEnterpriseAdministratorInvitationOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gEnterpriseAdministratorInvitationOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseAdministratorInvitationOrderField>
    _$gEnterpriseAdministratorInvitationOrderFieldValues =
    new BuiltSet<GEnterpriseAdministratorInvitationOrderField>(const <
        GEnterpriseAdministratorInvitationOrderField>[
  _$gEnterpriseAdministratorInvitationOrderFieldCREATED_AT,
]);

const GEnterpriseAdministratorRole
    _$gEnterpriseAdministratorRoleBILLING_MANAGER =
    const GEnterpriseAdministratorRole._('BILLING_MANAGER');
const GEnterpriseAdministratorRole _$gEnterpriseAdministratorRoleOWNER =
    const GEnterpriseAdministratorRole._('OWNER');

GEnterpriseAdministratorRole _$gEnterpriseAdministratorRoleValueOf(
    String name) {
  switch (name) {
    case 'BILLING_MANAGER':
      return _$gEnterpriseAdministratorRoleBILLING_MANAGER;
    case 'OWNER':
      return _$gEnterpriseAdministratorRoleOWNER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseAdministratorRole>
    _$gEnterpriseAdministratorRoleValues = new BuiltSet<
        GEnterpriseAdministratorRole>(const <GEnterpriseAdministratorRole>[
  _$gEnterpriseAdministratorRoleBILLING_MANAGER,
  _$gEnterpriseAdministratorRoleOWNER,
]);

const GEnterpriseDefaultRepositoryPermissionSettingValue
    _$gEnterpriseDefaultRepositoryPermissionSettingValueADMIN =
    const GEnterpriseDefaultRepositoryPermissionSettingValue._('ADMIN');
const GEnterpriseDefaultRepositoryPermissionSettingValue
    _$gEnterpriseDefaultRepositoryPermissionSettingValueNONE =
    const GEnterpriseDefaultRepositoryPermissionSettingValue._('NONE');
const GEnterpriseDefaultRepositoryPermissionSettingValue
    _$gEnterpriseDefaultRepositoryPermissionSettingValueNO_POLICY =
    const GEnterpriseDefaultRepositoryPermissionSettingValue._('NO_POLICY');
const GEnterpriseDefaultRepositoryPermissionSettingValue
    _$gEnterpriseDefaultRepositoryPermissionSettingValueREAD =
    const GEnterpriseDefaultRepositoryPermissionSettingValue._('READ');
const GEnterpriseDefaultRepositoryPermissionSettingValue
    _$gEnterpriseDefaultRepositoryPermissionSettingValueWRITE =
    const GEnterpriseDefaultRepositoryPermissionSettingValue._('WRITE');

GEnterpriseDefaultRepositoryPermissionSettingValue
    _$gEnterpriseDefaultRepositoryPermissionSettingValueValueOf(String name) {
  switch (name) {
    case 'ADMIN':
      return _$gEnterpriseDefaultRepositoryPermissionSettingValueADMIN;
    case 'NONE':
      return _$gEnterpriseDefaultRepositoryPermissionSettingValueNONE;
    case 'NO_POLICY':
      return _$gEnterpriseDefaultRepositoryPermissionSettingValueNO_POLICY;
    case 'READ':
      return _$gEnterpriseDefaultRepositoryPermissionSettingValueREAD;
    case 'WRITE':
      return _$gEnterpriseDefaultRepositoryPermissionSettingValueWRITE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseDefaultRepositoryPermissionSettingValue>
    _$gEnterpriseDefaultRepositoryPermissionSettingValueValues =
    new BuiltSet<GEnterpriseDefaultRepositoryPermissionSettingValue>(const <
        GEnterpriseDefaultRepositoryPermissionSettingValue>[
  _$gEnterpriseDefaultRepositoryPermissionSettingValueADMIN,
  _$gEnterpriseDefaultRepositoryPermissionSettingValueNONE,
  _$gEnterpriseDefaultRepositoryPermissionSettingValueNO_POLICY,
  _$gEnterpriseDefaultRepositoryPermissionSettingValueREAD,
  _$gEnterpriseDefaultRepositoryPermissionSettingValueWRITE,
]);

const GEnterpriseEnabledDisabledSettingValue
    _$gEnterpriseEnabledDisabledSettingValueDISABLED =
    const GEnterpriseEnabledDisabledSettingValue._('DISABLED');
const GEnterpriseEnabledDisabledSettingValue
    _$gEnterpriseEnabledDisabledSettingValueENABLED =
    const GEnterpriseEnabledDisabledSettingValue._('ENABLED');
const GEnterpriseEnabledDisabledSettingValue
    _$gEnterpriseEnabledDisabledSettingValueNO_POLICY =
    const GEnterpriseEnabledDisabledSettingValue._('NO_POLICY');

GEnterpriseEnabledDisabledSettingValue
    _$gEnterpriseEnabledDisabledSettingValueValueOf(String name) {
  switch (name) {
    case 'DISABLED':
      return _$gEnterpriseEnabledDisabledSettingValueDISABLED;
    case 'ENABLED':
      return _$gEnterpriseEnabledDisabledSettingValueENABLED;
    case 'NO_POLICY':
      return _$gEnterpriseEnabledDisabledSettingValueNO_POLICY;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseEnabledDisabledSettingValue>
    _$gEnterpriseEnabledDisabledSettingValueValues =
    new BuiltSet<GEnterpriseEnabledDisabledSettingValue>(const <
        GEnterpriseEnabledDisabledSettingValue>[
  _$gEnterpriseEnabledDisabledSettingValueDISABLED,
  _$gEnterpriseEnabledDisabledSettingValueENABLED,
  _$gEnterpriseEnabledDisabledSettingValueNO_POLICY,
]);

const GEnterpriseEnabledSettingValue _$gEnterpriseEnabledSettingValueENABLED =
    const GEnterpriseEnabledSettingValue._('ENABLED');
const GEnterpriseEnabledSettingValue _$gEnterpriseEnabledSettingValueNO_POLICY =
    const GEnterpriseEnabledSettingValue._('NO_POLICY');

GEnterpriseEnabledSettingValue _$gEnterpriseEnabledSettingValueValueOf(
    String name) {
  switch (name) {
    case 'ENABLED':
      return _$gEnterpriseEnabledSettingValueENABLED;
    case 'NO_POLICY':
      return _$gEnterpriseEnabledSettingValueNO_POLICY;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseEnabledSettingValue>
    _$gEnterpriseEnabledSettingValueValues = new BuiltSet<
        GEnterpriseEnabledSettingValue>(const <GEnterpriseEnabledSettingValue>[
  _$gEnterpriseEnabledSettingValueENABLED,
  _$gEnterpriseEnabledSettingValueNO_POLICY,
]);

const GEnterpriseMemberOrderField _$gEnterpriseMemberOrderFieldCREATED_AT =
    const GEnterpriseMemberOrderField._('CREATED_AT');
const GEnterpriseMemberOrderField _$gEnterpriseMemberOrderFieldLOGIN =
    const GEnterpriseMemberOrderField._('LOGIN');

GEnterpriseMemberOrderField _$gEnterpriseMemberOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gEnterpriseMemberOrderFieldCREATED_AT;
    case 'LOGIN':
      return _$gEnterpriseMemberOrderFieldLOGIN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseMemberOrderField>
    _$gEnterpriseMemberOrderFieldValues = new BuiltSet<
        GEnterpriseMemberOrderField>(const <GEnterpriseMemberOrderField>[
  _$gEnterpriseMemberOrderFieldCREATED_AT,
  _$gEnterpriseMemberOrderFieldLOGIN,
]);

const GEnterpriseMembersCanCreateRepositoriesSettingValue
    _$gEnterpriseMembersCanCreateRepositoriesSettingValueALL =
    const GEnterpriseMembersCanCreateRepositoriesSettingValue._('ALL');
const GEnterpriseMembersCanCreateRepositoriesSettingValue
    _$gEnterpriseMembersCanCreateRepositoriesSettingValueDISABLED =
    const GEnterpriseMembersCanCreateRepositoriesSettingValue._('DISABLED');
const GEnterpriseMembersCanCreateRepositoriesSettingValue
    _$gEnterpriseMembersCanCreateRepositoriesSettingValueNO_POLICY =
    const GEnterpriseMembersCanCreateRepositoriesSettingValue._('NO_POLICY');
const GEnterpriseMembersCanCreateRepositoriesSettingValue
    _$gEnterpriseMembersCanCreateRepositoriesSettingValuePRIVATE =
    const GEnterpriseMembersCanCreateRepositoriesSettingValue._('PRIVATE');
const GEnterpriseMembersCanCreateRepositoriesSettingValue
    _$gEnterpriseMembersCanCreateRepositoriesSettingValuePUBLIC =
    const GEnterpriseMembersCanCreateRepositoriesSettingValue._('PUBLIC');

GEnterpriseMembersCanCreateRepositoriesSettingValue
    _$gEnterpriseMembersCanCreateRepositoriesSettingValueValueOf(String name) {
  switch (name) {
    case 'ALL':
      return _$gEnterpriseMembersCanCreateRepositoriesSettingValueALL;
    case 'DISABLED':
      return _$gEnterpriseMembersCanCreateRepositoriesSettingValueDISABLED;
    case 'NO_POLICY':
      return _$gEnterpriseMembersCanCreateRepositoriesSettingValueNO_POLICY;
    case 'PRIVATE':
      return _$gEnterpriseMembersCanCreateRepositoriesSettingValuePRIVATE;
    case 'PUBLIC':
      return _$gEnterpriseMembersCanCreateRepositoriesSettingValuePUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseMembersCanCreateRepositoriesSettingValue>
    _$gEnterpriseMembersCanCreateRepositoriesSettingValueValues =
    new BuiltSet<GEnterpriseMembersCanCreateRepositoriesSettingValue>(const <
        GEnterpriseMembersCanCreateRepositoriesSettingValue>[
  _$gEnterpriseMembersCanCreateRepositoriesSettingValueALL,
  _$gEnterpriseMembersCanCreateRepositoriesSettingValueDISABLED,
  _$gEnterpriseMembersCanCreateRepositoriesSettingValueNO_POLICY,
  _$gEnterpriseMembersCanCreateRepositoriesSettingValuePRIVATE,
  _$gEnterpriseMembersCanCreateRepositoriesSettingValuePUBLIC,
]);

const GEnterpriseMembersCanMakePurchasesSettingValue
    _$gEnterpriseMembersCanMakePurchasesSettingValueDISABLED =
    const GEnterpriseMembersCanMakePurchasesSettingValue._('DISABLED');
const GEnterpriseMembersCanMakePurchasesSettingValue
    _$gEnterpriseMembersCanMakePurchasesSettingValueENABLED =
    const GEnterpriseMembersCanMakePurchasesSettingValue._('ENABLED');

GEnterpriseMembersCanMakePurchasesSettingValue
    _$gEnterpriseMembersCanMakePurchasesSettingValueValueOf(String name) {
  switch (name) {
    case 'DISABLED':
      return _$gEnterpriseMembersCanMakePurchasesSettingValueDISABLED;
    case 'ENABLED':
      return _$gEnterpriseMembersCanMakePurchasesSettingValueENABLED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseMembersCanMakePurchasesSettingValue>
    _$gEnterpriseMembersCanMakePurchasesSettingValueValues =
    new BuiltSet<GEnterpriseMembersCanMakePurchasesSettingValue>(const <
        GEnterpriseMembersCanMakePurchasesSettingValue>[
  _$gEnterpriseMembersCanMakePurchasesSettingValueDISABLED,
  _$gEnterpriseMembersCanMakePurchasesSettingValueENABLED,
]);

const GEnterpriseServerInstallationOrderField
    _$gEnterpriseServerInstallationOrderFieldCREATED_AT =
    const GEnterpriseServerInstallationOrderField._('CREATED_AT');
const GEnterpriseServerInstallationOrderField
    _$gEnterpriseServerInstallationOrderFieldCUSTOMER_NAME =
    const GEnterpriseServerInstallationOrderField._('CUSTOMER_NAME');
const GEnterpriseServerInstallationOrderField
    _$gEnterpriseServerInstallationOrderFieldHOST_NAME =
    const GEnterpriseServerInstallationOrderField._('HOST_NAME');

GEnterpriseServerInstallationOrderField
    _$gEnterpriseServerInstallationOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gEnterpriseServerInstallationOrderFieldCREATED_AT;
    case 'CUSTOMER_NAME':
      return _$gEnterpriseServerInstallationOrderFieldCUSTOMER_NAME;
    case 'HOST_NAME':
      return _$gEnterpriseServerInstallationOrderFieldHOST_NAME;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseServerInstallationOrderField>
    _$gEnterpriseServerInstallationOrderFieldValues =
    new BuiltSet<GEnterpriseServerInstallationOrderField>(const <
        GEnterpriseServerInstallationOrderField>[
  _$gEnterpriseServerInstallationOrderFieldCREATED_AT,
  _$gEnterpriseServerInstallationOrderFieldCUSTOMER_NAME,
  _$gEnterpriseServerInstallationOrderFieldHOST_NAME,
]);

const GEnterpriseServerUserAccountEmailOrderField
    _$gEnterpriseServerUserAccountEmailOrderFieldEMAIL =
    const GEnterpriseServerUserAccountEmailOrderField._('EMAIL');

GEnterpriseServerUserAccountEmailOrderField
    _$gEnterpriseServerUserAccountEmailOrderFieldValueOf(String name) {
  switch (name) {
    case 'EMAIL':
      return _$gEnterpriseServerUserAccountEmailOrderFieldEMAIL;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseServerUserAccountEmailOrderField>
    _$gEnterpriseServerUserAccountEmailOrderFieldValues =
    new BuiltSet<GEnterpriseServerUserAccountEmailOrderField>(const <
        GEnterpriseServerUserAccountEmailOrderField>[
  _$gEnterpriseServerUserAccountEmailOrderFieldEMAIL,
]);

const GEnterpriseServerUserAccountOrderField
    _$gEnterpriseServerUserAccountOrderFieldLOGIN =
    const GEnterpriseServerUserAccountOrderField._('LOGIN');
const GEnterpriseServerUserAccountOrderField
    _$gEnterpriseServerUserAccountOrderFieldREMOTE_CREATED_AT =
    const GEnterpriseServerUserAccountOrderField._('REMOTE_CREATED_AT');

GEnterpriseServerUserAccountOrderField
    _$gEnterpriseServerUserAccountOrderFieldValueOf(String name) {
  switch (name) {
    case 'LOGIN':
      return _$gEnterpriseServerUserAccountOrderFieldLOGIN;
    case 'REMOTE_CREATED_AT':
      return _$gEnterpriseServerUserAccountOrderFieldREMOTE_CREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseServerUserAccountOrderField>
    _$gEnterpriseServerUserAccountOrderFieldValues =
    new BuiltSet<GEnterpriseServerUserAccountOrderField>(const <
        GEnterpriseServerUserAccountOrderField>[
  _$gEnterpriseServerUserAccountOrderFieldLOGIN,
  _$gEnterpriseServerUserAccountOrderFieldREMOTE_CREATED_AT,
]);

const GEnterpriseServerUserAccountsUploadOrderField
    _$gEnterpriseServerUserAccountsUploadOrderFieldCREATED_AT =
    const GEnterpriseServerUserAccountsUploadOrderField._('CREATED_AT');

GEnterpriseServerUserAccountsUploadOrderField
    _$gEnterpriseServerUserAccountsUploadOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gEnterpriseServerUserAccountsUploadOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseServerUserAccountsUploadOrderField>
    _$gEnterpriseServerUserAccountsUploadOrderFieldValues =
    new BuiltSet<GEnterpriseServerUserAccountsUploadOrderField>(const <
        GEnterpriseServerUserAccountsUploadOrderField>[
  _$gEnterpriseServerUserAccountsUploadOrderFieldCREATED_AT,
]);

const GEnterpriseServerUserAccountsUploadSyncState
    _$gEnterpriseServerUserAccountsUploadSyncStateFAILURE =
    const GEnterpriseServerUserAccountsUploadSyncState._('FAILURE');
const GEnterpriseServerUserAccountsUploadSyncState
    _$gEnterpriseServerUserAccountsUploadSyncStatePENDING =
    const GEnterpriseServerUserAccountsUploadSyncState._('PENDING');
const GEnterpriseServerUserAccountsUploadSyncState
    _$gEnterpriseServerUserAccountsUploadSyncStateSUCCESS =
    const GEnterpriseServerUserAccountsUploadSyncState._('SUCCESS');

GEnterpriseServerUserAccountsUploadSyncState
    _$gEnterpriseServerUserAccountsUploadSyncStateValueOf(String name) {
  switch (name) {
    case 'FAILURE':
      return _$gEnterpriseServerUserAccountsUploadSyncStateFAILURE;
    case 'PENDING':
      return _$gEnterpriseServerUserAccountsUploadSyncStatePENDING;
    case 'SUCCESS':
      return _$gEnterpriseServerUserAccountsUploadSyncStateSUCCESS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseServerUserAccountsUploadSyncState>
    _$gEnterpriseServerUserAccountsUploadSyncStateValues =
    new BuiltSet<GEnterpriseServerUserAccountsUploadSyncState>(const <
        GEnterpriseServerUserAccountsUploadSyncState>[
  _$gEnterpriseServerUserAccountsUploadSyncStateFAILURE,
  _$gEnterpriseServerUserAccountsUploadSyncStatePENDING,
  _$gEnterpriseServerUserAccountsUploadSyncStateSUCCESS,
]);

const GEnterpriseUserAccountMembershipRole
    _$gEnterpriseUserAccountMembershipRoleMEMBER =
    const GEnterpriseUserAccountMembershipRole._('MEMBER');
const GEnterpriseUserAccountMembershipRole
    _$gEnterpriseUserAccountMembershipRoleOWNER =
    const GEnterpriseUserAccountMembershipRole._('OWNER');

GEnterpriseUserAccountMembershipRole
    _$gEnterpriseUserAccountMembershipRoleValueOf(String name) {
  switch (name) {
    case 'MEMBER':
      return _$gEnterpriseUserAccountMembershipRoleMEMBER;
    case 'OWNER':
      return _$gEnterpriseUserAccountMembershipRoleOWNER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseUserAccountMembershipRole>
    _$gEnterpriseUserAccountMembershipRoleValues =
    new BuiltSet<GEnterpriseUserAccountMembershipRole>(const <
        GEnterpriseUserAccountMembershipRole>[
  _$gEnterpriseUserAccountMembershipRoleMEMBER,
  _$gEnterpriseUserAccountMembershipRoleOWNER,
]);

const GEnterpriseUserDeployment _$gEnterpriseUserDeploymentCLOUD =
    const GEnterpriseUserDeployment._('CLOUD');
const GEnterpriseUserDeployment _$gEnterpriseUserDeploymentSERVER =
    const GEnterpriseUserDeployment._('SERVER');

GEnterpriseUserDeployment _$gEnterpriseUserDeploymentValueOf(String name) {
  switch (name) {
    case 'CLOUD':
      return _$gEnterpriseUserDeploymentCLOUD;
    case 'SERVER':
      return _$gEnterpriseUserDeploymentSERVER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GEnterpriseUserDeployment> _$gEnterpriseUserDeploymentValues =
    new BuiltSet<GEnterpriseUserDeployment>(const <GEnterpriseUserDeployment>[
  _$gEnterpriseUserDeploymentCLOUD,
  _$gEnterpriseUserDeploymentSERVER,
]);

const GFileViewedState _$gFileViewedStateDISMISSED =
    const GFileViewedState._('DISMISSED');
const GFileViewedState _$gFileViewedStateUNVIEWED =
    const GFileViewedState._('UNVIEWED');
const GFileViewedState _$gFileViewedStateVIEWED =
    const GFileViewedState._('VIEWED');

GFileViewedState _$gFileViewedStateValueOf(String name) {
  switch (name) {
    case 'DISMISSED':
      return _$gFileViewedStateDISMISSED;
    case 'UNVIEWED':
      return _$gFileViewedStateUNVIEWED;
    case 'VIEWED':
      return _$gFileViewedStateVIEWED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GFileViewedState> _$gFileViewedStateValues =
    new BuiltSet<GFileViewedState>(const <GFileViewedState>[
  _$gFileViewedStateDISMISSED,
  _$gFileViewedStateUNVIEWED,
  _$gFileViewedStateVIEWED,
]);

const GFundingPlatform _$gFundingPlatformCOMMUNITY_BRIDGE =
    const GFundingPlatform._('COMMUNITY_BRIDGE');
const GFundingPlatform _$gFundingPlatformCUSTOM =
    const GFundingPlatform._('CUSTOM');
const GFundingPlatform _$gFundingPlatformGITHUB =
    const GFundingPlatform._('GITHUB');
const GFundingPlatform _$gFundingPlatformISSUEHUNT =
    const GFundingPlatform._('ISSUEHUNT');
const GFundingPlatform _$gFundingPlatformKO_FI =
    const GFundingPlatform._('KO_FI');
const GFundingPlatform _$gFundingPlatformLIBERAPAY =
    const GFundingPlatform._('LIBERAPAY');
const GFundingPlatform _$gFundingPlatformOPEN_COLLECTIVE =
    const GFundingPlatform._('OPEN_COLLECTIVE');
const GFundingPlatform _$gFundingPlatformOTECHIE =
    const GFundingPlatform._('OTECHIE');
const GFundingPlatform _$gFundingPlatformPATREON =
    const GFundingPlatform._('PATREON');
const GFundingPlatform _$gFundingPlatformTIDELIFT =
    const GFundingPlatform._('TIDELIFT');

GFundingPlatform _$gFundingPlatformValueOf(String name) {
  switch (name) {
    case 'COMMUNITY_BRIDGE':
      return _$gFundingPlatformCOMMUNITY_BRIDGE;
    case 'CUSTOM':
      return _$gFundingPlatformCUSTOM;
    case 'GITHUB':
      return _$gFundingPlatformGITHUB;
    case 'ISSUEHUNT':
      return _$gFundingPlatformISSUEHUNT;
    case 'KO_FI':
      return _$gFundingPlatformKO_FI;
    case 'LIBERAPAY':
      return _$gFundingPlatformLIBERAPAY;
    case 'OPEN_COLLECTIVE':
      return _$gFundingPlatformOPEN_COLLECTIVE;
    case 'OTECHIE':
      return _$gFundingPlatformOTECHIE;
    case 'PATREON':
      return _$gFundingPlatformPATREON;
    case 'TIDELIFT':
      return _$gFundingPlatformTIDELIFT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GFundingPlatform> _$gFundingPlatformValues =
    new BuiltSet<GFundingPlatform>(const <GFundingPlatform>[
  _$gFundingPlatformCOMMUNITY_BRIDGE,
  _$gFundingPlatformCUSTOM,
  _$gFundingPlatformGITHUB,
  _$gFundingPlatformISSUEHUNT,
  _$gFundingPlatformKO_FI,
  _$gFundingPlatformLIBERAPAY,
  _$gFundingPlatformOPEN_COLLECTIVE,
  _$gFundingPlatformOTECHIE,
  _$gFundingPlatformPATREON,
  _$gFundingPlatformTIDELIFT,
]);

const GGistOrderField _$gGistOrderFieldCREATED_AT =
    const GGistOrderField._('CREATED_AT');
const GGistOrderField _$gGistOrderFieldPUSHED_AT =
    const GGistOrderField._('PUSHED_AT');
const GGistOrderField _$gGistOrderFieldUPDATED_AT =
    const GGistOrderField._('UPDATED_AT');

GGistOrderField _$gGistOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gGistOrderFieldCREATED_AT;
    case 'PUSHED_AT':
      return _$gGistOrderFieldPUSHED_AT;
    case 'UPDATED_AT':
      return _$gGistOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GGistOrderField> _$gGistOrderFieldValues =
    new BuiltSet<GGistOrderField>(const <GGistOrderField>[
  _$gGistOrderFieldCREATED_AT,
  _$gGistOrderFieldPUSHED_AT,
  _$gGistOrderFieldUPDATED_AT,
]);

const GGistPrivacy _$gGistPrivacyALL = const GGistPrivacy._('ALL');
const GGistPrivacy _$gGistPrivacyPUBLIC = const GGistPrivacy._('PUBLIC');
const GGistPrivacy _$gGistPrivacySECRET = const GGistPrivacy._('SECRET');

GGistPrivacy _$gGistPrivacyValueOf(String name) {
  switch (name) {
    case 'ALL':
      return _$gGistPrivacyALL;
    case 'PUBLIC':
      return _$gGistPrivacyPUBLIC;
    case 'SECRET':
      return _$gGistPrivacySECRET;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GGistPrivacy> _$gGistPrivacyValues =
    new BuiltSet<GGistPrivacy>(const <GGistPrivacy>[
  _$gGistPrivacyALL,
  _$gGistPrivacyPUBLIC,
  _$gGistPrivacySECRET,
]);

const GGitSignatureState _$gGitSignatureStateBAD_CERT =
    const GGitSignatureState._('BAD_CERT');
const GGitSignatureState _$gGitSignatureStateBAD_EMAIL =
    const GGitSignatureState._('BAD_EMAIL');
const GGitSignatureState _$gGitSignatureStateEXPIRED_KEY =
    const GGitSignatureState._('EXPIRED_KEY');
const GGitSignatureState _$gGitSignatureStateGPGVERIFY_ERROR =
    const GGitSignatureState._('GPGVERIFY_ERROR');
const GGitSignatureState _$gGitSignatureStateGPGVERIFY_UNAVAILABLE =
    const GGitSignatureState._('GPGVERIFY_UNAVAILABLE');
const GGitSignatureState _$gGitSignatureStateINVALID =
    const GGitSignatureState._('INVALID');
const GGitSignatureState _$gGitSignatureStateMALFORMED_SIG =
    const GGitSignatureState._('MALFORMED_SIG');
const GGitSignatureState _$gGitSignatureStateNOT_SIGNING_KEY =
    const GGitSignatureState._('NOT_SIGNING_KEY');
const GGitSignatureState _$gGitSignatureStateNO_USER =
    const GGitSignatureState._('NO_USER');
const GGitSignatureState _$gGitSignatureStateOCSP_ERROR =
    const GGitSignatureState._('OCSP_ERROR');
const GGitSignatureState _$gGitSignatureStateOCSP_PENDING =
    const GGitSignatureState._('OCSP_PENDING');
const GGitSignatureState _$gGitSignatureStateOCSP_REVOKED =
    const GGitSignatureState._('OCSP_REVOKED');
const GGitSignatureState _$gGitSignatureStateUNKNOWN_KEY =
    const GGitSignatureState._('UNKNOWN_KEY');
const GGitSignatureState _$gGitSignatureStateUNKNOWN_SIG_TYPE =
    const GGitSignatureState._('UNKNOWN_SIG_TYPE');
const GGitSignatureState _$gGitSignatureStateUNSIGNED =
    const GGitSignatureState._('UNSIGNED');
const GGitSignatureState _$gGitSignatureStateUNVERIFIED_EMAIL =
    const GGitSignatureState._('UNVERIFIED_EMAIL');
const GGitSignatureState _$gGitSignatureStateVALID =
    const GGitSignatureState._('VALID');

GGitSignatureState _$gGitSignatureStateValueOf(String name) {
  switch (name) {
    case 'BAD_CERT':
      return _$gGitSignatureStateBAD_CERT;
    case 'BAD_EMAIL':
      return _$gGitSignatureStateBAD_EMAIL;
    case 'EXPIRED_KEY':
      return _$gGitSignatureStateEXPIRED_KEY;
    case 'GPGVERIFY_ERROR':
      return _$gGitSignatureStateGPGVERIFY_ERROR;
    case 'GPGVERIFY_UNAVAILABLE':
      return _$gGitSignatureStateGPGVERIFY_UNAVAILABLE;
    case 'INVALID':
      return _$gGitSignatureStateINVALID;
    case 'MALFORMED_SIG':
      return _$gGitSignatureStateMALFORMED_SIG;
    case 'NOT_SIGNING_KEY':
      return _$gGitSignatureStateNOT_SIGNING_KEY;
    case 'NO_USER':
      return _$gGitSignatureStateNO_USER;
    case 'OCSP_ERROR':
      return _$gGitSignatureStateOCSP_ERROR;
    case 'OCSP_PENDING':
      return _$gGitSignatureStateOCSP_PENDING;
    case 'OCSP_REVOKED':
      return _$gGitSignatureStateOCSP_REVOKED;
    case 'UNKNOWN_KEY':
      return _$gGitSignatureStateUNKNOWN_KEY;
    case 'UNKNOWN_SIG_TYPE':
      return _$gGitSignatureStateUNKNOWN_SIG_TYPE;
    case 'UNSIGNED':
      return _$gGitSignatureStateUNSIGNED;
    case 'UNVERIFIED_EMAIL':
      return _$gGitSignatureStateUNVERIFIED_EMAIL;
    case 'VALID':
      return _$gGitSignatureStateVALID;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GGitSignatureState> _$gGitSignatureStateValues =
    new BuiltSet<GGitSignatureState>(const <GGitSignatureState>[
  _$gGitSignatureStateBAD_CERT,
  _$gGitSignatureStateBAD_EMAIL,
  _$gGitSignatureStateEXPIRED_KEY,
  _$gGitSignatureStateGPGVERIFY_ERROR,
  _$gGitSignatureStateGPGVERIFY_UNAVAILABLE,
  _$gGitSignatureStateINVALID,
  _$gGitSignatureStateMALFORMED_SIG,
  _$gGitSignatureStateNOT_SIGNING_KEY,
  _$gGitSignatureStateNO_USER,
  _$gGitSignatureStateOCSP_ERROR,
  _$gGitSignatureStateOCSP_PENDING,
  _$gGitSignatureStateOCSP_REVOKED,
  _$gGitSignatureStateUNKNOWN_KEY,
  _$gGitSignatureStateUNKNOWN_SIG_TYPE,
  _$gGitSignatureStateUNSIGNED,
  _$gGitSignatureStateUNVERIFIED_EMAIL,
  _$gGitSignatureStateVALID,
]);

const GIdentityProviderConfigurationState
    _$gIdentityProviderConfigurationStateCONFIGURED =
    const GIdentityProviderConfigurationState._('CONFIGURED');
const GIdentityProviderConfigurationState
    _$gIdentityProviderConfigurationStateENFORCED =
    const GIdentityProviderConfigurationState._('ENFORCED');
const GIdentityProviderConfigurationState
    _$gIdentityProviderConfigurationStateUNCONFIGURED =
    const GIdentityProviderConfigurationState._('UNCONFIGURED');

GIdentityProviderConfigurationState
    _$gIdentityProviderConfigurationStateValueOf(String name) {
  switch (name) {
    case 'CONFIGURED':
      return _$gIdentityProviderConfigurationStateCONFIGURED;
    case 'ENFORCED':
      return _$gIdentityProviderConfigurationStateENFORCED;
    case 'UNCONFIGURED':
      return _$gIdentityProviderConfigurationStateUNCONFIGURED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GIdentityProviderConfigurationState>
    _$gIdentityProviderConfigurationStateValues =
    new BuiltSet<GIdentityProviderConfigurationState>(const <
        GIdentityProviderConfigurationState>[
  _$gIdentityProviderConfigurationStateCONFIGURED,
  _$gIdentityProviderConfigurationStateENFORCED,
  _$gIdentityProviderConfigurationStateUNCONFIGURED,
]);

const GIpAllowListEnabledSettingValue
    _$gIpAllowListEnabledSettingValueDISABLED =
    const GIpAllowListEnabledSettingValue._('DISABLED');
const GIpAllowListEnabledSettingValue _$gIpAllowListEnabledSettingValueENABLED =
    const GIpAllowListEnabledSettingValue._('ENABLED');

GIpAllowListEnabledSettingValue _$gIpAllowListEnabledSettingValueValueOf(
    String name) {
  switch (name) {
    case 'DISABLED':
      return _$gIpAllowListEnabledSettingValueDISABLED;
    case 'ENABLED':
      return _$gIpAllowListEnabledSettingValueENABLED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GIpAllowListEnabledSettingValue>
    _$gIpAllowListEnabledSettingValueValues =
    new BuiltSet<GIpAllowListEnabledSettingValue>(const <
        GIpAllowListEnabledSettingValue>[
  _$gIpAllowListEnabledSettingValueDISABLED,
  _$gIpAllowListEnabledSettingValueENABLED,
]);

const GIpAllowListEntryOrderField
    _$gIpAllowListEntryOrderFieldALLOW_LIST_VALUE =
    const GIpAllowListEntryOrderField._('ALLOW_LIST_VALUE');
const GIpAllowListEntryOrderField _$gIpAllowListEntryOrderFieldCREATED_AT =
    const GIpAllowListEntryOrderField._('CREATED_AT');

GIpAllowListEntryOrderField _$gIpAllowListEntryOrderFieldValueOf(String name) {
  switch (name) {
    case 'ALLOW_LIST_VALUE':
      return _$gIpAllowListEntryOrderFieldALLOW_LIST_VALUE;
    case 'CREATED_AT':
      return _$gIpAllowListEntryOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GIpAllowListEntryOrderField>
    _$gIpAllowListEntryOrderFieldValues = new BuiltSet<
        GIpAllowListEntryOrderField>(const <GIpAllowListEntryOrderField>[
  _$gIpAllowListEntryOrderFieldALLOW_LIST_VALUE,
  _$gIpAllowListEntryOrderFieldCREATED_AT,
]);

const GIssueCommentOrderField _$gIssueCommentOrderFieldUPDATED_AT =
    const GIssueCommentOrderField._('UPDATED_AT');

GIssueCommentOrderField _$gIssueCommentOrderFieldValueOf(String name) {
  switch (name) {
    case 'UPDATED_AT':
      return _$gIssueCommentOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GIssueCommentOrderField> _$gIssueCommentOrderFieldValues =
    new BuiltSet<GIssueCommentOrderField>(const <GIssueCommentOrderField>[
  _$gIssueCommentOrderFieldUPDATED_AT,
]);

const GIssueOrderField _$gIssueOrderFieldCOMMENTS =
    const GIssueOrderField._('COMMENTS');
const GIssueOrderField _$gIssueOrderFieldCREATED_AT =
    const GIssueOrderField._('CREATED_AT');
const GIssueOrderField _$gIssueOrderFieldUPDATED_AT =
    const GIssueOrderField._('UPDATED_AT');

GIssueOrderField _$gIssueOrderFieldValueOf(String name) {
  switch (name) {
    case 'COMMENTS':
      return _$gIssueOrderFieldCOMMENTS;
    case 'CREATED_AT':
      return _$gIssueOrderFieldCREATED_AT;
    case 'UPDATED_AT':
      return _$gIssueOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GIssueOrderField> _$gIssueOrderFieldValues =
    new BuiltSet<GIssueOrderField>(const <GIssueOrderField>[
  _$gIssueOrderFieldCOMMENTS,
  _$gIssueOrderFieldCREATED_AT,
  _$gIssueOrderFieldUPDATED_AT,
]);

const GIssueState _$gIssueStateCLOSED = const GIssueState._('CLOSED');
const GIssueState _$gIssueStateOPEN = const GIssueState._('OPEN');

GIssueState _$gIssueStateValueOf(String name) {
  switch (name) {
    case 'CLOSED':
      return _$gIssueStateCLOSED;
    case 'OPEN':
      return _$gIssueStateOPEN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GIssueState> _$gIssueStateValues =
    new BuiltSet<GIssueState>(const <GIssueState>[
  _$gIssueStateCLOSED,
  _$gIssueStateOPEN,
]);

const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeADDED_TO_PROJECT_EVENT =
    const GIssueTimelineItemsItemType._('ADDED_TO_PROJECT_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeASSIGNED_EVENT =
    const GIssueTimelineItemsItemType._('ASSIGNED_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeCLOSED_EVENT =
    const GIssueTimelineItemsItemType._('CLOSED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeCOMMENT_DELETED_EVENT =
    const GIssueTimelineItemsItemType._('COMMENT_DELETED_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeCONNECTED_EVENT =
    const GIssueTimelineItemsItemType._('CONNECTED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeCONVERTED_NOTE_TO_ISSUE_EVENT =
    const GIssueTimelineItemsItemType._('CONVERTED_NOTE_TO_ISSUE_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeCROSS_REFERENCED_EVENT =
    const GIssueTimelineItemsItemType._('CROSS_REFERENCED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeDEMILESTONED_EVENT =
    const GIssueTimelineItemsItemType._('DEMILESTONED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeDISCONNECTED_EVENT =
    const GIssueTimelineItemsItemType._('DISCONNECTED_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeISSUE_COMMENT =
    const GIssueTimelineItemsItemType._('ISSUE_COMMENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeLABELED_EVENT =
    const GIssueTimelineItemsItemType._('LABELED_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeLOCKED_EVENT =
    const GIssueTimelineItemsItemType._('LOCKED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeMARKED_AS_DUPLICATE_EVENT =
    const GIssueTimelineItemsItemType._('MARKED_AS_DUPLICATE_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeMENTIONED_EVENT =
    const GIssueTimelineItemsItemType._('MENTIONED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeMILESTONED_EVENT =
    const GIssueTimelineItemsItemType._('MILESTONED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeMOVED_COLUMNS_IN_PROJECT_EVENT =
    const GIssueTimelineItemsItemType._('MOVED_COLUMNS_IN_PROJECT_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypePINNED_EVENT =
    const GIssueTimelineItemsItemType._('PINNED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeREFERENCED_EVENT =
    const GIssueTimelineItemsItemType._('REFERENCED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeREMOVED_FROM_PROJECT_EVENT =
    const GIssueTimelineItemsItemType._('REMOVED_FROM_PROJECT_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeRENAMED_TITLE_EVENT =
    const GIssueTimelineItemsItemType._('RENAMED_TITLE_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeREOPENED_EVENT =
    const GIssueTimelineItemsItemType._('REOPENED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeSUBSCRIBED_EVENT =
    const GIssueTimelineItemsItemType._('SUBSCRIBED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeTRANSFERRED_EVENT =
    const GIssueTimelineItemsItemType._('TRANSFERRED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeUNASSIGNED_EVENT =
    const GIssueTimelineItemsItemType._('UNASSIGNED_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeUNLABELED_EVENT =
    const GIssueTimelineItemsItemType._('UNLABELED_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeUNLOCKED_EVENT =
    const GIssueTimelineItemsItemType._('UNLOCKED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeUNMARKED_AS_DUPLICATE_EVENT =
    const GIssueTimelineItemsItemType._('UNMARKED_AS_DUPLICATE_EVENT');
const GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeUNPINNED_EVENT =
    const GIssueTimelineItemsItemType._('UNPINNED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeUNSUBSCRIBED_EVENT =
    const GIssueTimelineItemsItemType._('UNSUBSCRIBED_EVENT');
const GIssueTimelineItemsItemType
    _$gIssueTimelineItemsItemTypeUSER_BLOCKED_EVENT =
    const GIssueTimelineItemsItemType._('USER_BLOCKED_EVENT');

GIssueTimelineItemsItemType _$gIssueTimelineItemsItemTypeValueOf(String name) {
  switch (name) {
    case 'ADDED_TO_PROJECT_EVENT':
      return _$gIssueTimelineItemsItemTypeADDED_TO_PROJECT_EVENT;
    case 'ASSIGNED_EVENT':
      return _$gIssueTimelineItemsItemTypeASSIGNED_EVENT;
    case 'CLOSED_EVENT':
      return _$gIssueTimelineItemsItemTypeCLOSED_EVENT;
    case 'COMMENT_DELETED_EVENT':
      return _$gIssueTimelineItemsItemTypeCOMMENT_DELETED_EVENT;
    case 'CONNECTED_EVENT':
      return _$gIssueTimelineItemsItemTypeCONNECTED_EVENT;
    case 'CONVERTED_NOTE_TO_ISSUE_EVENT':
      return _$gIssueTimelineItemsItemTypeCONVERTED_NOTE_TO_ISSUE_EVENT;
    case 'CROSS_REFERENCED_EVENT':
      return _$gIssueTimelineItemsItemTypeCROSS_REFERENCED_EVENT;
    case 'DEMILESTONED_EVENT':
      return _$gIssueTimelineItemsItemTypeDEMILESTONED_EVENT;
    case 'DISCONNECTED_EVENT':
      return _$gIssueTimelineItemsItemTypeDISCONNECTED_EVENT;
    case 'ISSUE_COMMENT':
      return _$gIssueTimelineItemsItemTypeISSUE_COMMENT;
    case 'LABELED_EVENT':
      return _$gIssueTimelineItemsItemTypeLABELED_EVENT;
    case 'LOCKED_EVENT':
      return _$gIssueTimelineItemsItemTypeLOCKED_EVENT;
    case 'MARKED_AS_DUPLICATE_EVENT':
      return _$gIssueTimelineItemsItemTypeMARKED_AS_DUPLICATE_EVENT;
    case 'MENTIONED_EVENT':
      return _$gIssueTimelineItemsItemTypeMENTIONED_EVENT;
    case 'MILESTONED_EVENT':
      return _$gIssueTimelineItemsItemTypeMILESTONED_EVENT;
    case 'MOVED_COLUMNS_IN_PROJECT_EVENT':
      return _$gIssueTimelineItemsItemTypeMOVED_COLUMNS_IN_PROJECT_EVENT;
    case 'PINNED_EVENT':
      return _$gIssueTimelineItemsItemTypePINNED_EVENT;
    case 'REFERENCED_EVENT':
      return _$gIssueTimelineItemsItemTypeREFERENCED_EVENT;
    case 'REMOVED_FROM_PROJECT_EVENT':
      return _$gIssueTimelineItemsItemTypeREMOVED_FROM_PROJECT_EVENT;
    case 'RENAMED_TITLE_EVENT':
      return _$gIssueTimelineItemsItemTypeRENAMED_TITLE_EVENT;
    case 'REOPENED_EVENT':
      return _$gIssueTimelineItemsItemTypeREOPENED_EVENT;
    case 'SUBSCRIBED_EVENT':
      return _$gIssueTimelineItemsItemTypeSUBSCRIBED_EVENT;
    case 'TRANSFERRED_EVENT':
      return _$gIssueTimelineItemsItemTypeTRANSFERRED_EVENT;
    case 'UNASSIGNED_EVENT':
      return _$gIssueTimelineItemsItemTypeUNASSIGNED_EVENT;
    case 'UNLABELED_EVENT':
      return _$gIssueTimelineItemsItemTypeUNLABELED_EVENT;
    case 'UNLOCKED_EVENT':
      return _$gIssueTimelineItemsItemTypeUNLOCKED_EVENT;
    case 'UNMARKED_AS_DUPLICATE_EVENT':
      return _$gIssueTimelineItemsItemTypeUNMARKED_AS_DUPLICATE_EVENT;
    case 'UNPINNED_EVENT':
      return _$gIssueTimelineItemsItemTypeUNPINNED_EVENT;
    case 'UNSUBSCRIBED_EVENT':
      return _$gIssueTimelineItemsItemTypeUNSUBSCRIBED_EVENT;
    case 'USER_BLOCKED_EVENT':
      return _$gIssueTimelineItemsItemTypeUSER_BLOCKED_EVENT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GIssueTimelineItemsItemType>
    _$gIssueTimelineItemsItemTypeValues = new BuiltSet<
        GIssueTimelineItemsItemType>(const <GIssueTimelineItemsItemType>[
  _$gIssueTimelineItemsItemTypeADDED_TO_PROJECT_EVENT,
  _$gIssueTimelineItemsItemTypeASSIGNED_EVENT,
  _$gIssueTimelineItemsItemTypeCLOSED_EVENT,
  _$gIssueTimelineItemsItemTypeCOMMENT_DELETED_EVENT,
  _$gIssueTimelineItemsItemTypeCONNECTED_EVENT,
  _$gIssueTimelineItemsItemTypeCONVERTED_NOTE_TO_ISSUE_EVENT,
  _$gIssueTimelineItemsItemTypeCROSS_REFERENCED_EVENT,
  _$gIssueTimelineItemsItemTypeDEMILESTONED_EVENT,
  _$gIssueTimelineItemsItemTypeDISCONNECTED_EVENT,
  _$gIssueTimelineItemsItemTypeISSUE_COMMENT,
  _$gIssueTimelineItemsItemTypeLABELED_EVENT,
  _$gIssueTimelineItemsItemTypeLOCKED_EVENT,
  _$gIssueTimelineItemsItemTypeMARKED_AS_DUPLICATE_EVENT,
  _$gIssueTimelineItemsItemTypeMENTIONED_EVENT,
  _$gIssueTimelineItemsItemTypeMILESTONED_EVENT,
  _$gIssueTimelineItemsItemTypeMOVED_COLUMNS_IN_PROJECT_EVENT,
  _$gIssueTimelineItemsItemTypePINNED_EVENT,
  _$gIssueTimelineItemsItemTypeREFERENCED_EVENT,
  _$gIssueTimelineItemsItemTypeREMOVED_FROM_PROJECT_EVENT,
  _$gIssueTimelineItemsItemTypeRENAMED_TITLE_EVENT,
  _$gIssueTimelineItemsItemTypeREOPENED_EVENT,
  _$gIssueTimelineItemsItemTypeSUBSCRIBED_EVENT,
  _$gIssueTimelineItemsItemTypeTRANSFERRED_EVENT,
  _$gIssueTimelineItemsItemTypeUNASSIGNED_EVENT,
  _$gIssueTimelineItemsItemTypeUNLABELED_EVENT,
  _$gIssueTimelineItemsItemTypeUNLOCKED_EVENT,
  _$gIssueTimelineItemsItemTypeUNMARKED_AS_DUPLICATE_EVENT,
  _$gIssueTimelineItemsItemTypeUNPINNED_EVENT,
  _$gIssueTimelineItemsItemTypeUNSUBSCRIBED_EVENT,
  _$gIssueTimelineItemsItemTypeUSER_BLOCKED_EVENT,
]);

const GLabelOrderField _$gLabelOrderFieldCREATED_AT =
    const GLabelOrderField._('CREATED_AT');
const GLabelOrderField _$gLabelOrderFieldNAME =
    const GLabelOrderField._('NAME');

GLabelOrderField _$gLabelOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gLabelOrderFieldCREATED_AT;
    case 'NAME':
      return _$gLabelOrderFieldNAME;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GLabelOrderField> _$gLabelOrderFieldValues =
    new BuiltSet<GLabelOrderField>(const <GLabelOrderField>[
  _$gLabelOrderFieldCREATED_AT,
  _$gLabelOrderFieldNAME,
]);

const GLanguageOrderField _$gLanguageOrderFieldSIZE =
    const GLanguageOrderField._('SIZE');

GLanguageOrderField _$gLanguageOrderFieldValueOf(String name) {
  switch (name) {
    case 'SIZE':
      return _$gLanguageOrderFieldSIZE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GLanguageOrderField> _$gLanguageOrderFieldValues =
    new BuiltSet<GLanguageOrderField>(const <GLanguageOrderField>[
  _$gLanguageOrderFieldSIZE,
]);

const GLockReason _$gLockReasonOFF_TOPIC = const GLockReason._('OFF_TOPIC');
const GLockReason _$gLockReasonRESOLVED = const GLockReason._('RESOLVED');
const GLockReason _$gLockReasonSPAM = const GLockReason._('SPAM');
const GLockReason _$gLockReasonTOO_HEATED = const GLockReason._('TOO_HEATED');

GLockReason _$gLockReasonValueOf(String name) {
  switch (name) {
    case 'OFF_TOPIC':
      return _$gLockReasonOFF_TOPIC;
    case 'RESOLVED':
      return _$gLockReasonRESOLVED;
    case 'SPAM':
      return _$gLockReasonSPAM;
    case 'TOO_HEATED':
      return _$gLockReasonTOO_HEATED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GLockReason> _$gLockReasonValues =
    new BuiltSet<GLockReason>(const <GLockReason>[
  _$gLockReasonOFF_TOPIC,
  _$gLockReasonRESOLVED,
  _$gLockReasonSPAM,
  _$gLockReasonTOO_HEATED,
]);

const GMergeableState _$gMergeableStateCONFLICTING =
    const GMergeableState._('CONFLICTING');
const GMergeableState _$gMergeableStateMERGEABLE =
    const GMergeableState._('MERGEABLE');
const GMergeableState _$gMergeableStateUNKNOWN =
    const GMergeableState._('UNKNOWN');

GMergeableState _$gMergeableStateValueOf(String name) {
  switch (name) {
    case 'CONFLICTING':
      return _$gMergeableStateCONFLICTING;
    case 'MERGEABLE':
      return _$gMergeableStateMERGEABLE;
    case 'UNKNOWN':
      return _$gMergeableStateUNKNOWN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GMergeableState> _$gMergeableStateValues =
    new BuiltSet<GMergeableState>(const <GMergeableState>[
  _$gMergeableStateCONFLICTING,
  _$gMergeableStateMERGEABLE,
  _$gMergeableStateUNKNOWN,
]);

const GMilestoneOrderField _$gMilestoneOrderFieldCREATED_AT =
    const GMilestoneOrderField._('CREATED_AT');
const GMilestoneOrderField _$gMilestoneOrderFieldDUE_DATE =
    const GMilestoneOrderField._('DUE_DATE');
const GMilestoneOrderField _$gMilestoneOrderFieldNUMBER =
    const GMilestoneOrderField._('NUMBER');
const GMilestoneOrderField _$gMilestoneOrderFieldUPDATED_AT =
    const GMilestoneOrderField._('UPDATED_AT');

GMilestoneOrderField _$gMilestoneOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gMilestoneOrderFieldCREATED_AT;
    case 'DUE_DATE':
      return _$gMilestoneOrderFieldDUE_DATE;
    case 'NUMBER':
      return _$gMilestoneOrderFieldNUMBER;
    case 'UPDATED_AT':
      return _$gMilestoneOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GMilestoneOrderField> _$gMilestoneOrderFieldValues =
    new BuiltSet<GMilestoneOrderField>(const <GMilestoneOrderField>[
  _$gMilestoneOrderFieldCREATED_AT,
  _$gMilestoneOrderFieldDUE_DATE,
  _$gMilestoneOrderFieldNUMBER,
  _$gMilestoneOrderFieldUPDATED_AT,
]);

const GMilestoneState _$gMilestoneStateCLOSED =
    const GMilestoneState._('CLOSED');
const GMilestoneState _$gMilestoneStateOPEN = const GMilestoneState._('OPEN');

GMilestoneState _$gMilestoneStateValueOf(String name) {
  switch (name) {
    case 'CLOSED':
      return _$gMilestoneStateCLOSED;
    case 'OPEN':
      return _$gMilestoneStateOPEN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GMilestoneState> _$gMilestoneStateValues =
    new BuiltSet<GMilestoneState>(const <GMilestoneState>[
  _$gMilestoneStateCLOSED,
  _$gMilestoneStateOPEN,
]);

const GNotificationRestrictionSettingValue
    _$gNotificationRestrictionSettingValueDISABLED =
    const GNotificationRestrictionSettingValue._('DISABLED');
const GNotificationRestrictionSettingValue
    _$gNotificationRestrictionSettingValueENABLED =
    const GNotificationRestrictionSettingValue._('ENABLED');

GNotificationRestrictionSettingValue
    _$gNotificationRestrictionSettingValueValueOf(String name) {
  switch (name) {
    case 'DISABLED':
      return _$gNotificationRestrictionSettingValueDISABLED;
    case 'ENABLED':
      return _$gNotificationRestrictionSettingValueENABLED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GNotificationRestrictionSettingValue>
    _$gNotificationRestrictionSettingValueValues =
    new BuiltSet<GNotificationRestrictionSettingValue>(const <
        GNotificationRestrictionSettingValue>[
  _$gNotificationRestrictionSettingValueDISABLED,
  _$gNotificationRestrictionSettingValueENABLED,
]);

const GOauthApplicationCreateAuditEntryState
    _$gOauthApplicationCreateAuditEntryStateACTIVE =
    const GOauthApplicationCreateAuditEntryState._('ACTIVE');
const GOauthApplicationCreateAuditEntryState
    _$gOauthApplicationCreateAuditEntryStatePENDING_DELETION =
    const GOauthApplicationCreateAuditEntryState._('PENDING_DELETION');
const GOauthApplicationCreateAuditEntryState
    _$gOauthApplicationCreateAuditEntryStateSUSPENDED =
    const GOauthApplicationCreateAuditEntryState._('SUSPENDED');

GOauthApplicationCreateAuditEntryState
    _$gOauthApplicationCreateAuditEntryStateValueOf(String name) {
  switch (name) {
    case 'ACTIVE':
      return _$gOauthApplicationCreateAuditEntryStateACTIVE;
    case 'PENDING_DELETION':
      return _$gOauthApplicationCreateAuditEntryStatePENDING_DELETION;
    case 'SUSPENDED':
      return _$gOauthApplicationCreateAuditEntryStateSUSPENDED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOauthApplicationCreateAuditEntryState>
    _$gOauthApplicationCreateAuditEntryStateValues =
    new BuiltSet<GOauthApplicationCreateAuditEntryState>(const <
        GOauthApplicationCreateAuditEntryState>[
  _$gOauthApplicationCreateAuditEntryStateACTIVE,
  _$gOauthApplicationCreateAuditEntryStatePENDING_DELETION,
  _$gOauthApplicationCreateAuditEntryStateSUSPENDED,
]);

const GOperationType _$gOperationTypeACCESS = const GOperationType._('ACCESS');
const GOperationType _$gOperationTypeAUTHENTICATION =
    const GOperationType._('AUTHENTICATION');
const GOperationType _$gOperationTypeCREATE = const GOperationType._('CREATE');
const GOperationType _$gOperationTypeMODIFY = const GOperationType._('MODIFY');
const GOperationType _$gOperationTypeREMOVE = const GOperationType._('REMOVE');
const GOperationType _$gOperationTypeRESTORE =
    const GOperationType._('RESTORE');
const GOperationType _$gOperationTypeTRANSFER =
    const GOperationType._('TRANSFER');

GOperationType _$gOperationTypeValueOf(String name) {
  switch (name) {
    case 'ACCESS':
      return _$gOperationTypeACCESS;
    case 'AUTHENTICATION':
      return _$gOperationTypeAUTHENTICATION;
    case 'CREATE':
      return _$gOperationTypeCREATE;
    case 'MODIFY':
      return _$gOperationTypeMODIFY;
    case 'REMOVE':
      return _$gOperationTypeREMOVE;
    case 'RESTORE':
      return _$gOperationTypeRESTORE;
    case 'TRANSFER':
      return _$gOperationTypeTRANSFER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOperationType> _$gOperationTypeValues =
    new BuiltSet<GOperationType>(const <GOperationType>[
  _$gOperationTypeACCESS,
  _$gOperationTypeAUTHENTICATION,
  _$gOperationTypeCREATE,
  _$gOperationTypeMODIFY,
  _$gOperationTypeREMOVE,
  _$gOperationTypeRESTORE,
  _$gOperationTypeTRANSFER,
]);

const GOrderDirection _$gOrderDirectionASC = const GOrderDirection._('ASC');
const GOrderDirection _$gOrderDirectionDESC = const GOrderDirection._('DESC');

GOrderDirection _$gOrderDirectionValueOf(String name) {
  switch (name) {
    case 'ASC':
      return _$gOrderDirectionASC;
    case 'DESC':
      return _$gOrderDirectionDESC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrderDirection> _$gOrderDirectionValues =
    new BuiltSet<GOrderDirection>(const <GOrderDirection>[
  _$gOrderDirectionASC,
  _$gOrderDirectionDESC,
]);

const GOrgAddMemberAuditEntryPermission
    _$gOrgAddMemberAuditEntryPermissionADMIN =
    const GOrgAddMemberAuditEntryPermission._('ADMIN');
const GOrgAddMemberAuditEntryPermission
    _$gOrgAddMemberAuditEntryPermissionREAD =
    const GOrgAddMemberAuditEntryPermission._('READ');

GOrgAddMemberAuditEntryPermission _$gOrgAddMemberAuditEntryPermissionValueOf(
    String name) {
  switch (name) {
    case 'ADMIN':
      return _$gOrgAddMemberAuditEntryPermissionADMIN;
    case 'READ':
      return _$gOrgAddMemberAuditEntryPermissionREAD;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgAddMemberAuditEntryPermission>
    _$gOrgAddMemberAuditEntryPermissionValues =
    new BuiltSet<GOrgAddMemberAuditEntryPermission>(const <
        GOrgAddMemberAuditEntryPermission>[
  _$gOrgAddMemberAuditEntryPermissionADMIN,
  _$gOrgAddMemberAuditEntryPermissionREAD,
]);

const GOrgCreateAuditEntryBillingPlan
    _$gOrgCreateAuditEntryBillingPlanBUSINESS =
    const GOrgCreateAuditEntryBillingPlan._('BUSINESS');
const GOrgCreateAuditEntryBillingPlan
    _$gOrgCreateAuditEntryBillingPlanBUSINESS_PLUS =
    const GOrgCreateAuditEntryBillingPlan._('BUSINESS_PLUS');
const GOrgCreateAuditEntryBillingPlan _$gOrgCreateAuditEntryBillingPlanFREE =
    const GOrgCreateAuditEntryBillingPlan._('FREE');
const GOrgCreateAuditEntryBillingPlan
    _$gOrgCreateAuditEntryBillingPlanTIERED_PER_SEAT =
    const GOrgCreateAuditEntryBillingPlan._('TIERED_PER_SEAT');
const GOrgCreateAuditEntryBillingPlan
    _$gOrgCreateAuditEntryBillingPlanUNLIMITED =
    const GOrgCreateAuditEntryBillingPlan._('UNLIMITED');

GOrgCreateAuditEntryBillingPlan _$gOrgCreateAuditEntryBillingPlanValueOf(
    String name) {
  switch (name) {
    case 'BUSINESS':
      return _$gOrgCreateAuditEntryBillingPlanBUSINESS;
    case 'BUSINESS_PLUS':
      return _$gOrgCreateAuditEntryBillingPlanBUSINESS_PLUS;
    case 'FREE':
      return _$gOrgCreateAuditEntryBillingPlanFREE;
    case 'TIERED_PER_SEAT':
      return _$gOrgCreateAuditEntryBillingPlanTIERED_PER_SEAT;
    case 'UNLIMITED':
      return _$gOrgCreateAuditEntryBillingPlanUNLIMITED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgCreateAuditEntryBillingPlan>
    _$gOrgCreateAuditEntryBillingPlanValues =
    new BuiltSet<GOrgCreateAuditEntryBillingPlan>(const <
        GOrgCreateAuditEntryBillingPlan>[
  _$gOrgCreateAuditEntryBillingPlanBUSINESS,
  _$gOrgCreateAuditEntryBillingPlanBUSINESS_PLUS,
  _$gOrgCreateAuditEntryBillingPlanFREE,
  _$gOrgCreateAuditEntryBillingPlanTIERED_PER_SEAT,
  _$gOrgCreateAuditEntryBillingPlanUNLIMITED,
]);

const GOrgRemoveBillingManagerAuditEntryReason
    _$gOrgRemoveBillingManagerAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING =
    const GOrgRemoveBillingManagerAuditEntryReason._(
        'SAML_EXTERNAL_IDENTITY_MISSING');
const GOrgRemoveBillingManagerAuditEntryReason
    _$gOrgRemoveBillingManagerAuditEntryReasonSAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY =
    const GOrgRemoveBillingManagerAuditEntryReason._(
        'SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY');
const GOrgRemoveBillingManagerAuditEntryReason
    _$gOrgRemoveBillingManagerAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE =
    const GOrgRemoveBillingManagerAuditEntryReason._(
        'TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE');

GOrgRemoveBillingManagerAuditEntryReason
    _$gOrgRemoveBillingManagerAuditEntryReasonValueOf(String name) {
  switch (name) {
    case 'SAML_EXTERNAL_IDENTITY_MISSING':
      return _$gOrgRemoveBillingManagerAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING;
    case 'SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY':
      return _$gOrgRemoveBillingManagerAuditEntryReasonSAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY;
    case 'TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE':
      return _$gOrgRemoveBillingManagerAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgRemoveBillingManagerAuditEntryReason>
    _$gOrgRemoveBillingManagerAuditEntryReasonValues =
    new BuiltSet<GOrgRemoveBillingManagerAuditEntryReason>(const <
        GOrgRemoveBillingManagerAuditEntryReason>[
  _$gOrgRemoveBillingManagerAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING,
  _$gOrgRemoveBillingManagerAuditEntryReasonSAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY,
  _$gOrgRemoveBillingManagerAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE,
]);

const GOrgRemoveMemberAuditEntryMembershipType
    _$gOrgRemoveMemberAuditEntryMembershipTypeADMIN =
    const GOrgRemoveMemberAuditEntryMembershipType._('ADMIN');
const GOrgRemoveMemberAuditEntryMembershipType
    _$gOrgRemoveMemberAuditEntryMembershipTypeBILLING_MANAGER =
    const GOrgRemoveMemberAuditEntryMembershipType._('BILLING_MANAGER');
const GOrgRemoveMemberAuditEntryMembershipType
    _$gOrgRemoveMemberAuditEntryMembershipTypeDIRECT_MEMBER =
    const GOrgRemoveMemberAuditEntryMembershipType._('DIRECT_MEMBER');
const GOrgRemoveMemberAuditEntryMembershipType
    _$gOrgRemoveMemberAuditEntryMembershipTypeOUTSIDE_COLLABORATOR =
    const GOrgRemoveMemberAuditEntryMembershipType._('OUTSIDE_COLLABORATOR');
const GOrgRemoveMemberAuditEntryMembershipType
    _$gOrgRemoveMemberAuditEntryMembershipTypeUNAFFILIATED =
    const GOrgRemoveMemberAuditEntryMembershipType._('UNAFFILIATED');

GOrgRemoveMemberAuditEntryMembershipType
    _$gOrgRemoveMemberAuditEntryMembershipTypeValueOf(String name) {
  switch (name) {
    case 'ADMIN':
      return _$gOrgRemoveMemberAuditEntryMembershipTypeADMIN;
    case 'BILLING_MANAGER':
      return _$gOrgRemoveMemberAuditEntryMembershipTypeBILLING_MANAGER;
    case 'DIRECT_MEMBER':
      return _$gOrgRemoveMemberAuditEntryMembershipTypeDIRECT_MEMBER;
    case 'OUTSIDE_COLLABORATOR':
      return _$gOrgRemoveMemberAuditEntryMembershipTypeOUTSIDE_COLLABORATOR;
    case 'UNAFFILIATED':
      return _$gOrgRemoveMemberAuditEntryMembershipTypeUNAFFILIATED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgRemoveMemberAuditEntryMembershipType>
    _$gOrgRemoveMemberAuditEntryMembershipTypeValues =
    new BuiltSet<GOrgRemoveMemberAuditEntryMembershipType>(const <
        GOrgRemoveMemberAuditEntryMembershipType>[
  _$gOrgRemoveMemberAuditEntryMembershipTypeADMIN,
  _$gOrgRemoveMemberAuditEntryMembershipTypeBILLING_MANAGER,
  _$gOrgRemoveMemberAuditEntryMembershipTypeDIRECT_MEMBER,
  _$gOrgRemoveMemberAuditEntryMembershipTypeOUTSIDE_COLLABORATOR,
  _$gOrgRemoveMemberAuditEntryMembershipTypeUNAFFILIATED,
]);

const GOrgRemoveMemberAuditEntryReason
    _$gOrgRemoveMemberAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING =
    const GOrgRemoveMemberAuditEntryReason._('SAML_EXTERNAL_IDENTITY_MISSING');
const GOrgRemoveMemberAuditEntryReason
    _$gOrgRemoveMemberAuditEntryReasonSAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY =
    const GOrgRemoveMemberAuditEntryReason._(
        'SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY');
const GOrgRemoveMemberAuditEntryReason
    _$gOrgRemoveMemberAuditEntryReasonTWO_FACTOR_ACCOUNT_RECOVERY =
    const GOrgRemoveMemberAuditEntryReason._('TWO_FACTOR_ACCOUNT_RECOVERY');
const GOrgRemoveMemberAuditEntryReason
    _$gOrgRemoveMemberAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE =
    const GOrgRemoveMemberAuditEntryReason._(
        'TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE');
const GOrgRemoveMemberAuditEntryReason
    _$gOrgRemoveMemberAuditEntryReasonUSER_ACCOUNT_DELETED =
    const GOrgRemoveMemberAuditEntryReason._('USER_ACCOUNT_DELETED');

GOrgRemoveMemberAuditEntryReason _$gOrgRemoveMemberAuditEntryReasonValueOf(
    String name) {
  switch (name) {
    case 'SAML_EXTERNAL_IDENTITY_MISSING':
      return _$gOrgRemoveMemberAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING;
    case 'SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY':
      return _$gOrgRemoveMemberAuditEntryReasonSAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY;
    case 'TWO_FACTOR_ACCOUNT_RECOVERY':
      return _$gOrgRemoveMemberAuditEntryReasonTWO_FACTOR_ACCOUNT_RECOVERY;
    case 'TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE':
      return _$gOrgRemoveMemberAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE;
    case 'USER_ACCOUNT_DELETED':
      return _$gOrgRemoveMemberAuditEntryReasonUSER_ACCOUNT_DELETED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgRemoveMemberAuditEntryReason>
    _$gOrgRemoveMemberAuditEntryReasonValues =
    new BuiltSet<GOrgRemoveMemberAuditEntryReason>(const <
        GOrgRemoveMemberAuditEntryReason>[
  _$gOrgRemoveMemberAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING,
  _$gOrgRemoveMemberAuditEntryReasonSAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY,
  _$gOrgRemoveMemberAuditEntryReasonTWO_FACTOR_ACCOUNT_RECOVERY,
  _$gOrgRemoveMemberAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE,
  _$gOrgRemoveMemberAuditEntryReasonUSER_ACCOUNT_DELETED,
]);

const GOrgRemoveOutsideCollaboratorAuditEntryMembershipType
    _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeBILLING_MANAGER =
    const GOrgRemoveOutsideCollaboratorAuditEntryMembershipType._(
        'BILLING_MANAGER');
const GOrgRemoveOutsideCollaboratorAuditEntryMembershipType
    _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeOUTSIDE_COLLABORATOR =
    const GOrgRemoveOutsideCollaboratorAuditEntryMembershipType._(
        'OUTSIDE_COLLABORATOR');
const GOrgRemoveOutsideCollaboratorAuditEntryMembershipType
    _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeUNAFFILIATED =
    const GOrgRemoveOutsideCollaboratorAuditEntryMembershipType._(
        'UNAFFILIATED');

GOrgRemoveOutsideCollaboratorAuditEntryMembershipType
    _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeValueOf(
        String name) {
  switch (name) {
    case 'BILLING_MANAGER':
      return _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeBILLING_MANAGER;
    case 'OUTSIDE_COLLABORATOR':
      return _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeOUTSIDE_COLLABORATOR;
    case 'UNAFFILIATED':
      return _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeUNAFFILIATED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgRemoveOutsideCollaboratorAuditEntryMembershipType>
    _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeValues =
    new BuiltSet<GOrgRemoveOutsideCollaboratorAuditEntryMembershipType>(const <
        GOrgRemoveOutsideCollaboratorAuditEntryMembershipType>[
  _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeBILLING_MANAGER,
  _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeOUTSIDE_COLLABORATOR,
  _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeUNAFFILIATED,
]);

const GOrgRemoveOutsideCollaboratorAuditEntryReason
    _$gOrgRemoveOutsideCollaboratorAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING =
    const GOrgRemoveOutsideCollaboratorAuditEntryReason._(
        'SAML_EXTERNAL_IDENTITY_MISSING');
const GOrgRemoveOutsideCollaboratorAuditEntryReason
    _$gOrgRemoveOutsideCollaboratorAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE =
    const GOrgRemoveOutsideCollaboratorAuditEntryReason._(
        'TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE');

GOrgRemoveOutsideCollaboratorAuditEntryReason
    _$gOrgRemoveOutsideCollaboratorAuditEntryReasonValueOf(String name) {
  switch (name) {
    case 'SAML_EXTERNAL_IDENTITY_MISSING':
      return _$gOrgRemoveOutsideCollaboratorAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING;
    case 'TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE':
      return _$gOrgRemoveOutsideCollaboratorAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgRemoveOutsideCollaboratorAuditEntryReason>
    _$gOrgRemoveOutsideCollaboratorAuditEntryReasonValues =
    new BuiltSet<GOrgRemoveOutsideCollaboratorAuditEntryReason>(const <
        GOrgRemoveOutsideCollaboratorAuditEntryReason>[
  _$gOrgRemoveOutsideCollaboratorAuditEntryReasonSAML_EXTERNAL_IDENTITY_MISSING,
  _$gOrgRemoveOutsideCollaboratorAuditEntryReasonTWO_FACTOR_REQUIREMENT_NON_COMPLIANCE,
]);

const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission
    _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionADMIN =
    const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission._('ADMIN');
const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission
    _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionNONE =
    const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission._('NONE');
const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission
    _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionREAD =
    const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission._('READ');
const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission
    _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionWRITE =
    const GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission._('WRITE');

GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission
    _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionValueOf(
        String name) {
  switch (name) {
    case 'ADMIN':
      return _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionADMIN;
    case 'NONE':
      return _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionNONE;
    case 'READ':
      return _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionREAD;
    case 'WRITE':
      return _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionWRITE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission>
    _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionValues =
    new BuiltSet<GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission>(const <
        GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission>[
  _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionADMIN,
  _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionNONE,
  _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionREAD,
  _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionWRITE,
]);

const GOrgUpdateMemberAuditEntryPermission
    _$gOrgUpdateMemberAuditEntryPermissionADMIN =
    const GOrgUpdateMemberAuditEntryPermission._('ADMIN');
const GOrgUpdateMemberAuditEntryPermission
    _$gOrgUpdateMemberAuditEntryPermissionREAD =
    const GOrgUpdateMemberAuditEntryPermission._('READ');

GOrgUpdateMemberAuditEntryPermission
    _$gOrgUpdateMemberAuditEntryPermissionValueOf(String name) {
  switch (name) {
    case 'ADMIN':
      return _$gOrgUpdateMemberAuditEntryPermissionADMIN;
    case 'READ':
      return _$gOrgUpdateMemberAuditEntryPermissionREAD;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgUpdateMemberAuditEntryPermission>
    _$gOrgUpdateMemberAuditEntryPermissionValues =
    new BuiltSet<GOrgUpdateMemberAuditEntryPermission>(const <
        GOrgUpdateMemberAuditEntryPermission>[
  _$gOrgUpdateMemberAuditEntryPermissionADMIN,
  _$gOrgUpdateMemberAuditEntryPermissionREAD,
]);

const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityALL =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'ALL');
const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityINTERNAL =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'INTERNAL');
const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityNONE =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'NONE');
const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPRIVATE =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'PRIVATE');
const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPRIVATE_INTERNAL =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'PRIVATE_INTERNAL');
const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'PUBLIC');
const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC_INTERNAL =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'PUBLIC_INTERNAL');
const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC_PRIVATE =
    const GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility._(
        'PUBLIC_PRIVATE');

GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityValueOf(
        String name) {
  switch (name) {
    case 'ALL':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityALL;
    case 'INTERNAL':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityINTERNAL;
    case 'NONE':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityNONE;
    case 'PRIVATE':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPRIVATE;
    case 'PRIVATE_INTERNAL':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPRIVATE_INTERNAL;
    case 'PUBLIC':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC;
    case 'PUBLIC_INTERNAL':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC_INTERNAL;
    case 'PUBLIC_PRIVATE':
      return _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC_PRIVATE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility>
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityValues =
    new BuiltSet<GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility>(const <
        GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility>[
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityALL,
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityINTERNAL,
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityNONE,
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPRIVATE,
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPRIVATE_INTERNAL,
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC,
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC_INTERNAL,
  _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilityPUBLIC_PRIVATE,
]);

const GOrganizationInvitationRole _$gOrganizationInvitationRoleADMIN =
    const GOrganizationInvitationRole._('ADMIN');
const GOrganizationInvitationRole _$gOrganizationInvitationRoleBILLING_MANAGER =
    const GOrganizationInvitationRole._('BILLING_MANAGER');
const GOrganizationInvitationRole _$gOrganizationInvitationRoleDIRECT_MEMBER =
    const GOrganizationInvitationRole._('DIRECT_MEMBER');
const GOrganizationInvitationRole _$gOrganizationInvitationRoleREINSTATE =
    const GOrganizationInvitationRole._('REINSTATE');

GOrganizationInvitationRole _$gOrganizationInvitationRoleValueOf(String name) {
  switch (name) {
    case 'ADMIN':
      return _$gOrganizationInvitationRoleADMIN;
    case 'BILLING_MANAGER':
      return _$gOrganizationInvitationRoleBILLING_MANAGER;
    case 'DIRECT_MEMBER':
      return _$gOrganizationInvitationRoleDIRECT_MEMBER;
    case 'REINSTATE':
      return _$gOrganizationInvitationRoleREINSTATE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrganizationInvitationRole>
    _$gOrganizationInvitationRoleValues = new BuiltSet<
        GOrganizationInvitationRole>(const <GOrganizationInvitationRole>[
  _$gOrganizationInvitationRoleADMIN,
  _$gOrganizationInvitationRoleBILLING_MANAGER,
  _$gOrganizationInvitationRoleDIRECT_MEMBER,
  _$gOrganizationInvitationRoleREINSTATE,
]);

const GOrganizationInvitationType _$gOrganizationInvitationTypeEMAIL =
    const GOrganizationInvitationType._('EMAIL');
const GOrganizationInvitationType _$gOrganizationInvitationTypeUSER =
    const GOrganizationInvitationType._('USER');

GOrganizationInvitationType _$gOrganizationInvitationTypeValueOf(String name) {
  switch (name) {
    case 'EMAIL':
      return _$gOrganizationInvitationTypeEMAIL;
    case 'USER':
      return _$gOrganizationInvitationTypeUSER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrganizationInvitationType>
    _$gOrganizationInvitationTypeValues = new BuiltSet<
        GOrganizationInvitationType>(const <GOrganizationInvitationType>[
  _$gOrganizationInvitationTypeEMAIL,
  _$gOrganizationInvitationTypeUSER,
]);

const GOrganizationMemberRole _$gOrganizationMemberRoleADMIN =
    const GOrganizationMemberRole._('ADMIN');
const GOrganizationMemberRole _$gOrganizationMemberRoleMEMBER =
    const GOrganizationMemberRole._('MEMBER');

GOrganizationMemberRole _$gOrganizationMemberRoleValueOf(String name) {
  switch (name) {
    case 'ADMIN':
      return _$gOrganizationMemberRoleADMIN;
    case 'MEMBER':
      return _$gOrganizationMemberRoleMEMBER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrganizationMemberRole> _$gOrganizationMemberRoleValues =
    new BuiltSet<GOrganizationMemberRole>(const <GOrganizationMemberRole>[
  _$gOrganizationMemberRoleADMIN,
  _$gOrganizationMemberRoleMEMBER,
]);

const GOrganizationMembersCanCreateRepositoriesSettingValue
    _$gOrganizationMembersCanCreateRepositoriesSettingValueALL =
    const GOrganizationMembersCanCreateRepositoriesSettingValue._('ALL');
const GOrganizationMembersCanCreateRepositoriesSettingValue
    _$gOrganizationMembersCanCreateRepositoriesSettingValueDISABLED =
    const GOrganizationMembersCanCreateRepositoriesSettingValue._('DISABLED');
const GOrganizationMembersCanCreateRepositoriesSettingValue
    _$gOrganizationMembersCanCreateRepositoriesSettingValuePRIVATE =
    const GOrganizationMembersCanCreateRepositoriesSettingValue._('PRIVATE');

GOrganizationMembersCanCreateRepositoriesSettingValue
    _$gOrganizationMembersCanCreateRepositoriesSettingValueValueOf(
        String name) {
  switch (name) {
    case 'ALL':
      return _$gOrganizationMembersCanCreateRepositoriesSettingValueALL;
    case 'DISABLED':
      return _$gOrganizationMembersCanCreateRepositoriesSettingValueDISABLED;
    case 'PRIVATE':
      return _$gOrganizationMembersCanCreateRepositoriesSettingValuePRIVATE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrganizationMembersCanCreateRepositoriesSettingValue>
    _$gOrganizationMembersCanCreateRepositoriesSettingValueValues =
    new BuiltSet<GOrganizationMembersCanCreateRepositoriesSettingValue>(const <
        GOrganizationMembersCanCreateRepositoriesSettingValue>[
  _$gOrganizationMembersCanCreateRepositoriesSettingValueALL,
  _$gOrganizationMembersCanCreateRepositoriesSettingValueDISABLED,
  _$gOrganizationMembersCanCreateRepositoriesSettingValuePRIVATE,
]);

const GOrganizationOrderField _$gOrganizationOrderFieldCREATED_AT =
    const GOrganizationOrderField._('CREATED_AT');
const GOrganizationOrderField _$gOrganizationOrderFieldLOGIN =
    const GOrganizationOrderField._('LOGIN');

GOrganizationOrderField _$gOrganizationOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gOrganizationOrderFieldCREATED_AT;
    case 'LOGIN':
      return _$gOrganizationOrderFieldLOGIN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GOrganizationOrderField> _$gOrganizationOrderFieldValues =
    new BuiltSet<GOrganizationOrderField>(const <GOrganizationOrderField>[
  _$gOrganizationOrderFieldCREATED_AT,
  _$gOrganizationOrderFieldLOGIN,
]);

const GPackageFileOrderField _$gPackageFileOrderFieldCREATED_AT =
    const GPackageFileOrderField._('CREATED_AT');

GPackageFileOrderField _$gPackageFileOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gPackageFileOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPackageFileOrderField> _$gPackageFileOrderFieldValues =
    new BuiltSet<GPackageFileOrderField>(const <GPackageFileOrderField>[
  _$gPackageFileOrderFieldCREATED_AT,
]);

const GPackageOrderField _$gPackageOrderFieldCREATED_AT =
    const GPackageOrderField._('CREATED_AT');

GPackageOrderField _$gPackageOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gPackageOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPackageOrderField> _$gPackageOrderFieldValues =
    new BuiltSet<GPackageOrderField>(const <GPackageOrderField>[
  _$gPackageOrderFieldCREATED_AT,
]);

const GPackageType _$gPackageTypeDEBIAN = const GPackageType._('DEBIAN');
const GPackageType _$gPackageTypeDOCKER = const GPackageType._('DOCKER');
const GPackageType _$gPackageTypeMAVEN = const GPackageType._('MAVEN');
const GPackageType _$gPackageTypeNPM = const GPackageType._('NPM');
const GPackageType _$gPackageTypeNUGET = const GPackageType._('NUGET');
const GPackageType _$gPackageTypePYPI = const GPackageType._('PYPI');
const GPackageType _$gPackageTypeRUBYGEMS = const GPackageType._('RUBYGEMS');

GPackageType _$gPackageTypeValueOf(String name) {
  switch (name) {
    case 'DEBIAN':
      return _$gPackageTypeDEBIAN;
    case 'DOCKER':
      return _$gPackageTypeDOCKER;
    case 'MAVEN':
      return _$gPackageTypeMAVEN;
    case 'NPM':
      return _$gPackageTypeNPM;
    case 'NUGET':
      return _$gPackageTypeNUGET;
    case 'PYPI':
      return _$gPackageTypePYPI;
    case 'RUBYGEMS':
      return _$gPackageTypeRUBYGEMS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPackageType> _$gPackageTypeValues =
    new BuiltSet<GPackageType>(const <GPackageType>[
  _$gPackageTypeDEBIAN,
  _$gPackageTypeDOCKER,
  _$gPackageTypeMAVEN,
  _$gPackageTypeNPM,
  _$gPackageTypeNUGET,
  _$gPackageTypePYPI,
  _$gPackageTypeRUBYGEMS,
]);

const GPackageVersionOrderField _$gPackageVersionOrderFieldCREATED_AT =
    const GPackageVersionOrderField._('CREATED_AT');

GPackageVersionOrderField _$gPackageVersionOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gPackageVersionOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPackageVersionOrderField> _$gPackageVersionOrderFieldValues =
    new BuiltSet<GPackageVersionOrderField>(const <GPackageVersionOrderField>[
  _$gPackageVersionOrderFieldCREATED_AT,
]);

const GPinnableItemType _$gPinnableItemTypeGIST =
    const GPinnableItemType._('GIST');
const GPinnableItemType _$gPinnableItemTypeISSUE =
    const GPinnableItemType._('ISSUE');
const GPinnableItemType _$gPinnableItemTypeORGANIZATION =
    const GPinnableItemType._('ORGANIZATION');
const GPinnableItemType _$gPinnableItemTypePROJECT =
    const GPinnableItemType._('PROJECT');
const GPinnableItemType _$gPinnableItemTypePULL_REQUEST =
    const GPinnableItemType._('PULL_REQUEST');
const GPinnableItemType _$gPinnableItemTypeREPOSITORY =
    const GPinnableItemType._('REPOSITORY');
const GPinnableItemType _$gPinnableItemTypeTEAM =
    const GPinnableItemType._('TEAM');
const GPinnableItemType _$gPinnableItemTypeUSER =
    const GPinnableItemType._('USER');

GPinnableItemType _$gPinnableItemTypeValueOf(String name) {
  switch (name) {
    case 'GIST':
      return _$gPinnableItemTypeGIST;
    case 'ISSUE':
      return _$gPinnableItemTypeISSUE;
    case 'ORGANIZATION':
      return _$gPinnableItemTypeORGANIZATION;
    case 'PROJECT':
      return _$gPinnableItemTypePROJECT;
    case 'PULL_REQUEST':
      return _$gPinnableItemTypePULL_REQUEST;
    case 'REPOSITORY':
      return _$gPinnableItemTypeREPOSITORY;
    case 'TEAM':
      return _$gPinnableItemTypeTEAM;
    case 'USER':
      return _$gPinnableItemTypeUSER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPinnableItemType> _$gPinnableItemTypeValues =
    new BuiltSet<GPinnableItemType>(const <GPinnableItemType>[
  _$gPinnableItemTypeGIST,
  _$gPinnableItemTypeISSUE,
  _$gPinnableItemTypeORGANIZATION,
  _$gPinnableItemTypePROJECT,
  _$gPinnableItemTypePULL_REQUEST,
  _$gPinnableItemTypeREPOSITORY,
  _$gPinnableItemTypeTEAM,
  _$gPinnableItemTypeUSER,
]);

const GPinnedDiscussionGradient _$gPinnedDiscussionGradientBLUE_MINT =
    const GPinnedDiscussionGradient._('BLUE_MINT');
const GPinnedDiscussionGradient _$gPinnedDiscussionGradientBLUE_PURPLE =
    const GPinnedDiscussionGradient._('BLUE_PURPLE');
const GPinnedDiscussionGradient _$gPinnedDiscussionGradientPINK_BLUE =
    const GPinnedDiscussionGradient._('PINK_BLUE');
const GPinnedDiscussionGradient _$gPinnedDiscussionGradientPURPLE_CORAL =
    const GPinnedDiscussionGradient._('PURPLE_CORAL');
const GPinnedDiscussionGradient _$gPinnedDiscussionGradientRED_ORANGE =
    const GPinnedDiscussionGradient._('RED_ORANGE');

GPinnedDiscussionGradient _$gPinnedDiscussionGradientValueOf(String name) {
  switch (name) {
    case 'BLUE_MINT':
      return _$gPinnedDiscussionGradientBLUE_MINT;
    case 'BLUE_PURPLE':
      return _$gPinnedDiscussionGradientBLUE_PURPLE;
    case 'PINK_BLUE':
      return _$gPinnedDiscussionGradientPINK_BLUE;
    case 'PURPLE_CORAL':
      return _$gPinnedDiscussionGradientPURPLE_CORAL;
    case 'RED_ORANGE':
      return _$gPinnedDiscussionGradientRED_ORANGE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPinnedDiscussionGradient> _$gPinnedDiscussionGradientValues =
    new BuiltSet<GPinnedDiscussionGradient>(const <GPinnedDiscussionGradient>[
  _$gPinnedDiscussionGradientBLUE_MINT,
  _$gPinnedDiscussionGradientBLUE_PURPLE,
  _$gPinnedDiscussionGradientPINK_BLUE,
  _$gPinnedDiscussionGradientPURPLE_CORAL,
  _$gPinnedDiscussionGradientRED_ORANGE,
]);

const GPinnedDiscussionPattern _$gPinnedDiscussionPatternCHEVRON_UP =
    const GPinnedDiscussionPattern._('CHEVRON_UP');
const GPinnedDiscussionPattern _$gPinnedDiscussionPatternDOT =
    const GPinnedDiscussionPattern._('DOT');
const GPinnedDiscussionPattern _$gPinnedDiscussionPatternDOT_FILL =
    const GPinnedDiscussionPattern._('DOT_FILL');
const GPinnedDiscussionPattern _$gPinnedDiscussionPatternHEART_FILL =
    const GPinnedDiscussionPattern._('HEART_FILL');
const GPinnedDiscussionPattern _$gPinnedDiscussionPatternPLUS =
    const GPinnedDiscussionPattern._('PLUS');
const GPinnedDiscussionPattern _$gPinnedDiscussionPatternZAP =
    const GPinnedDiscussionPattern._('ZAP');

GPinnedDiscussionPattern _$gPinnedDiscussionPatternValueOf(String name) {
  switch (name) {
    case 'CHEVRON_UP':
      return _$gPinnedDiscussionPatternCHEVRON_UP;
    case 'DOT':
      return _$gPinnedDiscussionPatternDOT;
    case 'DOT_FILL':
      return _$gPinnedDiscussionPatternDOT_FILL;
    case 'HEART_FILL':
      return _$gPinnedDiscussionPatternHEART_FILL;
    case 'PLUS':
      return _$gPinnedDiscussionPatternPLUS;
    case 'ZAP':
      return _$gPinnedDiscussionPatternZAP;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPinnedDiscussionPattern> _$gPinnedDiscussionPatternValues =
    new BuiltSet<GPinnedDiscussionPattern>(const <GPinnedDiscussionPattern>[
  _$gPinnedDiscussionPatternCHEVRON_UP,
  _$gPinnedDiscussionPatternDOT,
  _$gPinnedDiscussionPatternDOT_FILL,
  _$gPinnedDiscussionPatternHEART_FILL,
  _$gPinnedDiscussionPatternPLUS,
  _$gPinnedDiscussionPatternZAP,
]);

const GProjectCardArchivedState _$gProjectCardArchivedStateARCHIVED =
    const GProjectCardArchivedState._('ARCHIVED');
const GProjectCardArchivedState _$gProjectCardArchivedStateNOT_ARCHIVED =
    const GProjectCardArchivedState._('NOT_ARCHIVED');

GProjectCardArchivedState _$gProjectCardArchivedStateValueOf(String name) {
  switch (name) {
    case 'ARCHIVED':
      return _$gProjectCardArchivedStateARCHIVED;
    case 'NOT_ARCHIVED':
      return _$gProjectCardArchivedStateNOT_ARCHIVED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GProjectCardArchivedState> _$gProjectCardArchivedStateValues =
    new BuiltSet<GProjectCardArchivedState>(const <GProjectCardArchivedState>[
  _$gProjectCardArchivedStateARCHIVED,
  _$gProjectCardArchivedStateNOT_ARCHIVED,
]);

const GProjectCardState _$gProjectCardStateCONTENT_ONLY =
    const GProjectCardState._('CONTENT_ONLY');
const GProjectCardState _$gProjectCardStateNOTE_ONLY =
    const GProjectCardState._('NOTE_ONLY');
const GProjectCardState _$gProjectCardStateREDACTED =
    const GProjectCardState._('REDACTED');

GProjectCardState _$gProjectCardStateValueOf(String name) {
  switch (name) {
    case 'CONTENT_ONLY':
      return _$gProjectCardStateCONTENT_ONLY;
    case 'NOTE_ONLY':
      return _$gProjectCardStateNOTE_ONLY;
    case 'REDACTED':
      return _$gProjectCardStateREDACTED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GProjectCardState> _$gProjectCardStateValues =
    new BuiltSet<GProjectCardState>(const <GProjectCardState>[
  _$gProjectCardStateCONTENT_ONLY,
  _$gProjectCardStateNOTE_ONLY,
  _$gProjectCardStateREDACTED,
]);

const GProjectColumnPurpose _$gProjectColumnPurposeDONE =
    const GProjectColumnPurpose._('DONE');
const GProjectColumnPurpose _$gProjectColumnPurposeIN_PROGRESS =
    const GProjectColumnPurpose._('IN_PROGRESS');
const GProjectColumnPurpose _$gProjectColumnPurposeTODO =
    const GProjectColumnPurpose._('TODO');

GProjectColumnPurpose _$gProjectColumnPurposeValueOf(String name) {
  switch (name) {
    case 'DONE':
      return _$gProjectColumnPurposeDONE;
    case 'IN_PROGRESS':
      return _$gProjectColumnPurposeIN_PROGRESS;
    case 'TODO':
      return _$gProjectColumnPurposeTODO;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GProjectColumnPurpose> _$gProjectColumnPurposeValues =
    new BuiltSet<GProjectColumnPurpose>(const <GProjectColumnPurpose>[
  _$gProjectColumnPurposeDONE,
  _$gProjectColumnPurposeIN_PROGRESS,
  _$gProjectColumnPurposeTODO,
]);

const GProjectOrderField _$gProjectOrderFieldCREATED_AT =
    const GProjectOrderField._('CREATED_AT');
const GProjectOrderField _$gProjectOrderFieldNAME =
    const GProjectOrderField._('NAME');
const GProjectOrderField _$gProjectOrderFieldUPDATED_AT =
    const GProjectOrderField._('UPDATED_AT');

GProjectOrderField _$gProjectOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gProjectOrderFieldCREATED_AT;
    case 'NAME':
      return _$gProjectOrderFieldNAME;
    case 'UPDATED_AT':
      return _$gProjectOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GProjectOrderField> _$gProjectOrderFieldValues =
    new BuiltSet<GProjectOrderField>(const <GProjectOrderField>[
  _$gProjectOrderFieldCREATED_AT,
  _$gProjectOrderFieldNAME,
  _$gProjectOrderFieldUPDATED_AT,
]);

const GProjectState _$gProjectStateCLOSED = const GProjectState._('CLOSED');
const GProjectState _$gProjectStateOPEN = const GProjectState._('OPEN');

GProjectState _$gProjectStateValueOf(String name) {
  switch (name) {
    case 'CLOSED':
      return _$gProjectStateCLOSED;
    case 'OPEN':
      return _$gProjectStateOPEN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GProjectState> _$gProjectStateValues =
    new BuiltSet<GProjectState>(const <GProjectState>[
  _$gProjectStateCLOSED,
  _$gProjectStateOPEN,
]);

const GProjectTemplate _$gProjectTemplateAUTOMATED_KANBAN_V2 =
    const GProjectTemplate._('AUTOMATED_KANBAN_V2');
const GProjectTemplate _$gProjectTemplateAUTOMATED_REVIEWS_KANBAN =
    const GProjectTemplate._('AUTOMATED_REVIEWS_KANBAN');
const GProjectTemplate _$gProjectTemplateBASIC_KANBAN =
    const GProjectTemplate._('BASIC_KANBAN');
const GProjectTemplate _$gProjectTemplateBUG_TRIAGE =
    const GProjectTemplate._('BUG_TRIAGE');

GProjectTemplate _$gProjectTemplateValueOf(String name) {
  switch (name) {
    case 'AUTOMATED_KANBAN_V2':
      return _$gProjectTemplateAUTOMATED_KANBAN_V2;
    case 'AUTOMATED_REVIEWS_KANBAN':
      return _$gProjectTemplateAUTOMATED_REVIEWS_KANBAN;
    case 'BASIC_KANBAN':
      return _$gProjectTemplateBASIC_KANBAN;
    case 'BUG_TRIAGE':
      return _$gProjectTemplateBUG_TRIAGE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GProjectTemplate> _$gProjectTemplateValues =
    new BuiltSet<GProjectTemplate>(const <GProjectTemplate>[
  _$gProjectTemplateAUTOMATED_KANBAN_V2,
  _$gProjectTemplateAUTOMATED_REVIEWS_KANBAN,
  _$gProjectTemplateBASIC_KANBAN,
  _$gProjectTemplateBUG_TRIAGE,
]);

const GPullRequestMergeMethod _$gPullRequestMergeMethodMERGE =
    const GPullRequestMergeMethod._('MERGE');
const GPullRequestMergeMethod _$gPullRequestMergeMethodREBASE =
    const GPullRequestMergeMethod._('REBASE');
const GPullRequestMergeMethod _$gPullRequestMergeMethodSQUASH =
    const GPullRequestMergeMethod._('SQUASH');

GPullRequestMergeMethod _$gPullRequestMergeMethodValueOf(String name) {
  switch (name) {
    case 'MERGE':
      return _$gPullRequestMergeMethodMERGE;
    case 'REBASE':
      return _$gPullRequestMergeMethodREBASE;
    case 'SQUASH':
      return _$gPullRequestMergeMethodSQUASH;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestMergeMethod> _$gPullRequestMergeMethodValues =
    new BuiltSet<GPullRequestMergeMethod>(const <GPullRequestMergeMethod>[
  _$gPullRequestMergeMethodMERGE,
  _$gPullRequestMergeMethodREBASE,
  _$gPullRequestMergeMethodSQUASH,
]);

const GPullRequestOrderField _$gPullRequestOrderFieldCREATED_AT =
    const GPullRequestOrderField._('CREATED_AT');
const GPullRequestOrderField _$gPullRequestOrderFieldUPDATED_AT =
    const GPullRequestOrderField._('UPDATED_AT');

GPullRequestOrderField _$gPullRequestOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gPullRequestOrderFieldCREATED_AT;
    case 'UPDATED_AT':
      return _$gPullRequestOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestOrderField> _$gPullRequestOrderFieldValues =
    new BuiltSet<GPullRequestOrderField>(const <GPullRequestOrderField>[
  _$gPullRequestOrderFieldCREATED_AT,
  _$gPullRequestOrderFieldUPDATED_AT,
]);

const GPullRequestReviewCommentState _$gPullRequestReviewCommentStatePENDING =
    const GPullRequestReviewCommentState._('PENDING');
const GPullRequestReviewCommentState _$gPullRequestReviewCommentStateSUBMITTED =
    const GPullRequestReviewCommentState._('SUBMITTED');

GPullRequestReviewCommentState _$gPullRequestReviewCommentStateValueOf(
    String name) {
  switch (name) {
    case 'PENDING':
      return _$gPullRequestReviewCommentStatePENDING;
    case 'SUBMITTED':
      return _$gPullRequestReviewCommentStateSUBMITTED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestReviewCommentState>
    _$gPullRequestReviewCommentStateValues = new BuiltSet<
        GPullRequestReviewCommentState>(const <GPullRequestReviewCommentState>[
  _$gPullRequestReviewCommentStatePENDING,
  _$gPullRequestReviewCommentStateSUBMITTED,
]);

const GPullRequestReviewDecision _$gPullRequestReviewDecisionAPPROVED =
    const GPullRequestReviewDecision._('APPROVED');
const GPullRequestReviewDecision _$gPullRequestReviewDecisionCHANGES_REQUESTED =
    const GPullRequestReviewDecision._('CHANGES_REQUESTED');
const GPullRequestReviewDecision _$gPullRequestReviewDecisionREVIEW_REQUIRED =
    const GPullRequestReviewDecision._('REVIEW_REQUIRED');

GPullRequestReviewDecision _$gPullRequestReviewDecisionValueOf(String name) {
  switch (name) {
    case 'APPROVED':
      return _$gPullRequestReviewDecisionAPPROVED;
    case 'CHANGES_REQUESTED':
      return _$gPullRequestReviewDecisionCHANGES_REQUESTED;
    case 'REVIEW_REQUIRED':
      return _$gPullRequestReviewDecisionREVIEW_REQUIRED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestReviewDecision> _$gPullRequestReviewDecisionValues =
    new BuiltSet<GPullRequestReviewDecision>(const <GPullRequestReviewDecision>[
  _$gPullRequestReviewDecisionAPPROVED,
  _$gPullRequestReviewDecisionCHANGES_REQUESTED,
  _$gPullRequestReviewDecisionREVIEW_REQUIRED,
]);

const GPullRequestReviewEvent _$gPullRequestReviewEventAPPROVE =
    const GPullRequestReviewEvent._('APPROVE');
const GPullRequestReviewEvent _$gPullRequestReviewEventCOMMENT =
    const GPullRequestReviewEvent._('COMMENT');
const GPullRequestReviewEvent _$gPullRequestReviewEventDISMISS =
    const GPullRequestReviewEvent._('DISMISS');
const GPullRequestReviewEvent _$gPullRequestReviewEventREQUEST_CHANGES =
    const GPullRequestReviewEvent._('REQUEST_CHANGES');

GPullRequestReviewEvent _$gPullRequestReviewEventValueOf(String name) {
  switch (name) {
    case 'APPROVE':
      return _$gPullRequestReviewEventAPPROVE;
    case 'COMMENT':
      return _$gPullRequestReviewEventCOMMENT;
    case 'DISMISS':
      return _$gPullRequestReviewEventDISMISS;
    case 'REQUEST_CHANGES':
      return _$gPullRequestReviewEventREQUEST_CHANGES;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestReviewEvent> _$gPullRequestReviewEventValues =
    new BuiltSet<GPullRequestReviewEvent>(const <GPullRequestReviewEvent>[
  _$gPullRequestReviewEventAPPROVE,
  _$gPullRequestReviewEventCOMMENT,
  _$gPullRequestReviewEventDISMISS,
  _$gPullRequestReviewEventREQUEST_CHANGES,
]);

const GPullRequestReviewState _$gPullRequestReviewStateAPPROVED =
    const GPullRequestReviewState._('APPROVED');
const GPullRequestReviewState _$gPullRequestReviewStateCHANGES_REQUESTED =
    const GPullRequestReviewState._('CHANGES_REQUESTED');
const GPullRequestReviewState _$gPullRequestReviewStateCOMMENTED =
    const GPullRequestReviewState._('COMMENTED');
const GPullRequestReviewState _$gPullRequestReviewStateDISMISSED =
    const GPullRequestReviewState._('DISMISSED');
const GPullRequestReviewState _$gPullRequestReviewStatePENDING =
    const GPullRequestReviewState._('PENDING');

GPullRequestReviewState _$gPullRequestReviewStateValueOf(String name) {
  switch (name) {
    case 'APPROVED':
      return _$gPullRequestReviewStateAPPROVED;
    case 'CHANGES_REQUESTED':
      return _$gPullRequestReviewStateCHANGES_REQUESTED;
    case 'COMMENTED':
      return _$gPullRequestReviewStateCOMMENTED;
    case 'DISMISSED':
      return _$gPullRequestReviewStateDISMISSED;
    case 'PENDING':
      return _$gPullRequestReviewStatePENDING;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestReviewState> _$gPullRequestReviewStateValues =
    new BuiltSet<GPullRequestReviewState>(const <GPullRequestReviewState>[
  _$gPullRequestReviewStateAPPROVED,
  _$gPullRequestReviewStateCHANGES_REQUESTED,
  _$gPullRequestReviewStateCOMMENTED,
  _$gPullRequestReviewStateDISMISSED,
  _$gPullRequestReviewStatePENDING,
]);

const GPullRequestState _$gPullRequestStateCLOSED =
    const GPullRequestState._('CLOSED');
const GPullRequestState _$gPullRequestStateMERGED =
    const GPullRequestState._('MERGED');
const GPullRequestState _$gPullRequestStateOPEN =
    const GPullRequestState._('OPEN');

GPullRequestState _$gPullRequestStateValueOf(String name) {
  switch (name) {
    case 'CLOSED':
      return _$gPullRequestStateCLOSED;
    case 'MERGED':
      return _$gPullRequestStateMERGED;
    case 'OPEN':
      return _$gPullRequestStateOPEN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestState> _$gPullRequestStateValues =
    new BuiltSet<GPullRequestState>(const <GPullRequestState>[
  _$gPullRequestStateCLOSED,
  _$gPullRequestStateMERGED,
  _$gPullRequestStateOPEN,
]);

const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeADDED_TO_PROJECT_EVENT =
    const GPullRequestTimelineItemsItemType._('ADDED_TO_PROJECT_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeASSIGNED_EVENT =
    const GPullRequestTimelineItemsItemType._('ASSIGNED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeAUTOMATIC_BASE_CHANGE_FAILED_EVENT =
    const GPullRequestTimelineItemsItemType._(
        'AUTOMATIC_BASE_CHANGE_FAILED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeAUTOMATIC_BASE_CHANGE_SUCCEEDED_EVENT =
    const GPullRequestTimelineItemsItemType._(
        'AUTOMATIC_BASE_CHANGE_SUCCEEDED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeAUTO_MERGE_DISABLED_EVENT =
    const GPullRequestTimelineItemsItemType._('AUTO_MERGE_DISABLED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeAUTO_MERGE_ENABLED_EVENT =
    const GPullRequestTimelineItemsItemType._('AUTO_MERGE_ENABLED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeAUTO_REBASE_ENABLED_EVENT =
    const GPullRequestTimelineItemsItemType._('AUTO_REBASE_ENABLED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeAUTO_SQUASH_ENABLED_EVENT =
    const GPullRequestTimelineItemsItemType._('AUTO_SQUASH_ENABLED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeBASE_REF_CHANGED_EVENT =
    const GPullRequestTimelineItemsItemType._('BASE_REF_CHANGED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeBASE_REF_DELETED_EVENT =
    const GPullRequestTimelineItemsItemType._('BASE_REF_DELETED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeBASE_REF_FORCE_PUSHED_EVENT =
    const GPullRequestTimelineItemsItemType._('BASE_REF_FORCE_PUSHED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeCLOSED_EVENT =
    const GPullRequestTimelineItemsItemType._('CLOSED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeCOMMENT_DELETED_EVENT =
    const GPullRequestTimelineItemsItemType._('COMMENT_DELETED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeCONNECTED_EVENT =
    const GPullRequestTimelineItemsItemType._('CONNECTED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeCONVERTED_NOTE_TO_ISSUE_EVENT =
    const GPullRequestTimelineItemsItemType._('CONVERTED_NOTE_TO_ISSUE_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeCONVERT_TO_DRAFT_EVENT =
    const GPullRequestTimelineItemsItemType._('CONVERT_TO_DRAFT_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeCROSS_REFERENCED_EVENT =
    const GPullRequestTimelineItemsItemType._('CROSS_REFERENCED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeDEMILESTONED_EVENT =
    const GPullRequestTimelineItemsItemType._('DEMILESTONED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeDEPLOYED_EVENT =
    const GPullRequestTimelineItemsItemType._('DEPLOYED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeDEPLOYMENT_ENVIRONMENT_CHANGED_EVENT =
    const GPullRequestTimelineItemsItemType._(
        'DEPLOYMENT_ENVIRONMENT_CHANGED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeDISCONNECTED_EVENT =
    const GPullRequestTimelineItemsItemType._('DISCONNECTED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeHEAD_REF_DELETED_EVENT =
    const GPullRequestTimelineItemsItemType._('HEAD_REF_DELETED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeHEAD_REF_FORCE_PUSHED_EVENT =
    const GPullRequestTimelineItemsItemType._('HEAD_REF_FORCE_PUSHED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeHEAD_REF_RESTORED_EVENT =
    const GPullRequestTimelineItemsItemType._('HEAD_REF_RESTORED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeISSUE_COMMENT =
    const GPullRequestTimelineItemsItemType._('ISSUE_COMMENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeLABELED_EVENT =
    const GPullRequestTimelineItemsItemType._('LABELED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeLOCKED_EVENT =
    const GPullRequestTimelineItemsItemType._('LOCKED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeMARKED_AS_DUPLICATE_EVENT =
    const GPullRequestTimelineItemsItemType._('MARKED_AS_DUPLICATE_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeMENTIONED_EVENT =
    const GPullRequestTimelineItemsItemType._('MENTIONED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeMERGED_EVENT =
    const GPullRequestTimelineItemsItemType._('MERGED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeMILESTONED_EVENT =
    const GPullRequestTimelineItemsItemType._('MILESTONED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeMOVED_COLUMNS_IN_PROJECT_EVENT =
    const GPullRequestTimelineItemsItemType._('MOVED_COLUMNS_IN_PROJECT_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypePINNED_EVENT =
    const GPullRequestTimelineItemsItemType._('PINNED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypePULL_REQUEST_COMMIT =
    const GPullRequestTimelineItemsItemType._('PULL_REQUEST_COMMIT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypePULL_REQUEST_COMMIT_COMMENT_THREAD =
    const GPullRequestTimelineItemsItemType._(
        'PULL_REQUEST_COMMIT_COMMENT_THREAD');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVIEW =
    const GPullRequestTimelineItemsItemType._('PULL_REQUEST_REVIEW');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVIEW_THREAD =
    const GPullRequestTimelineItemsItemType._('PULL_REQUEST_REVIEW_THREAD');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVISION_MARKER =
    const GPullRequestTimelineItemsItemType._('PULL_REQUEST_REVISION_MARKER');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeREADY_FOR_REVIEW_EVENT =
    const GPullRequestTimelineItemsItemType._('READY_FOR_REVIEW_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeREFERENCED_EVENT =
    const GPullRequestTimelineItemsItemType._('REFERENCED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeREMOVED_FROM_PROJECT_EVENT =
    const GPullRequestTimelineItemsItemType._('REMOVED_FROM_PROJECT_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeRENAMED_TITLE_EVENT =
    const GPullRequestTimelineItemsItemType._('RENAMED_TITLE_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeREOPENED_EVENT =
    const GPullRequestTimelineItemsItemType._('REOPENED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeREVIEW_DISMISSED_EVENT =
    const GPullRequestTimelineItemsItemType._('REVIEW_DISMISSED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeREVIEW_REQUESTED_EVENT =
    const GPullRequestTimelineItemsItemType._('REVIEW_REQUESTED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeREVIEW_REQUEST_REMOVED_EVENT =
    const GPullRequestTimelineItemsItemType._('REVIEW_REQUEST_REMOVED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeSUBSCRIBED_EVENT =
    const GPullRequestTimelineItemsItemType._('SUBSCRIBED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeTRANSFERRED_EVENT =
    const GPullRequestTimelineItemsItemType._('TRANSFERRED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeUNASSIGNED_EVENT =
    const GPullRequestTimelineItemsItemType._('UNASSIGNED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeUNLABELED_EVENT =
    const GPullRequestTimelineItemsItemType._('UNLABELED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeUNLOCKED_EVENT =
    const GPullRequestTimelineItemsItemType._('UNLOCKED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeUNMARKED_AS_DUPLICATE_EVENT =
    const GPullRequestTimelineItemsItemType._('UNMARKED_AS_DUPLICATE_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeUNPINNED_EVENT =
    const GPullRequestTimelineItemsItemType._('UNPINNED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeUNSUBSCRIBED_EVENT =
    const GPullRequestTimelineItemsItemType._('UNSUBSCRIBED_EVENT');
const GPullRequestTimelineItemsItemType
    _$gPullRequestTimelineItemsItemTypeUSER_BLOCKED_EVENT =
    const GPullRequestTimelineItemsItemType._('USER_BLOCKED_EVENT');

GPullRequestTimelineItemsItemType _$gPullRequestTimelineItemsItemTypeValueOf(
    String name) {
  switch (name) {
    case 'ADDED_TO_PROJECT_EVENT':
      return _$gPullRequestTimelineItemsItemTypeADDED_TO_PROJECT_EVENT;
    case 'ASSIGNED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeASSIGNED_EVENT;
    case 'AUTOMATIC_BASE_CHANGE_FAILED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeAUTOMATIC_BASE_CHANGE_FAILED_EVENT;
    case 'AUTOMATIC_BASE_CHANGE_SUCCEEDED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeAUTOMATIC_BASE_CHANGE_SUCCEEDED_EVENT;
    case 'AUTO_MERGE_DISABLED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeAUTO_MERGE_DISABLED_EVENT;
    case 'AUTO_MERGE_ENABLED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeAUTO_MERGE_ENABLED_EVENT;
    case 'AUTO_REBASE_ENABLED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeAUTO_REBASE_ENABLED_EVENT;
    case 'AUTO_SQUASH_ENABLED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeAUTO_SQUASH_ENABLED_EVENT;
    case 'BASE_REF_CHANGED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeBASE_REF_CHANGED_EVENT;
    case 'BASE_REF_DELETED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeBASE_REF_DELETED_EVENT;
    case 'BASE_REF_FORCE_PUSHED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeBASE_REF_FORCE_PUSHED_EVENT;
    case 'CLOSED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeCLOSED_EVENT;
    case 'COMMENT_DELETED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeCOMMENT_DELETED_EVENT;
    case 'CONNECTED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeCONNECTED_EVENT;
    case 'CONVERTED_NOTE_TO_ISSUE_EVENT':
      return _$gPullRequestTimelineItemsItemTypeCONVERTED_NOTE_TO_ISSUE_EVENT;
    case 'CONVERT_TO_DRAFT_EVENT':
      return _$gPullRequestTimelineItemsItemTypeCONVERT_TO_DRAFT_EVENT;
    case 'CROSS_REFERENCED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeCROSS_REFERENCED_EVENT;
    case 'DEMILESTONED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeDEMILESTONED_EVENT;
    case 'DEPLOYED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeDEPLOYED_EVENT;
    case 'DEPLOYMENT_ENVIRONMENT_CHANGED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeDEPLOYMENT_ENVIRONMENT_CHANGED_EVENT;
    case 'DISCONNECTED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeDISCONNECTED_EVENT;
    case 'HEAD_REF_DELETED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeHEAD_REF_DELETED_EVENT;
    case 'HEAD_REF_FORCE_PUSHED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeHEAD_REF_FORCE_PUSHED_EVENT;
    case 'HEAD_REF_RESTORED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeHEAD_REF_RESTORED_EVENT;
    case 'ISSUE_COMMENT':
      return _$gPullRequestTimelineItemsItemTypeISSUE_COMMENT;
    case 'LABELED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeLABELED_EVENT;
    case 'LOCKED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeLOCKED_EVENT;
    case 'MARKED_AS_DUPLICATE_EVENT':
      return _$gPullRequestTimelineItemsItemTypeMARKED_AS_DUPLICATE_EVENT;
    case 'MENTIONED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeMENTIONED_EVENT;
    case 'MERGED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeMERGED_EVENT;
    case 'MILESTONED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeMILESTONED_EVENT;
    case 'MOVED_COLUMNS_IN_PROJECT_EVENT':
      return _$gPullRequestTimelineItemsItemTypeMOVED_COLUMNS_IN_PROJECT_EVENT;
    case 'PINNED_EVENT':
      return _$gPullRequestTimelineItemsItemTypePINNED_EVENT;
    case 'PULL_REQUEST_COMMIT':
      return _$gPullRequestTimelineItemsItemTypePULL_REQUEST_COMMIT;
    case 'PULL_REQUEST_COMMIT_COMMENT_THREAD':
      return _$gPullRequestTimelineItemsItemTypePULL_REQUEST_COMMIT_COMMENT_THREAD;
    case 'PULL_REQUEST_REVIEW':
      return _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVIEW;
    case 'PULL_REQUEST_REVIEW_THREAD':
      return _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVIEW_THREAD;
    case 'PULL_REQUEST_REVISION_MARKER':
      return _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVISION_MARKER;
    case 'READY_FOR_REVIEW_EVENT':
      return _$gPullRequestTimelineItemsItemTypeREADY_FOR_REVIEW_EVENT;
    case 'REFERENCED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeREFERENCED_EVENT;
    case 'REMOVED_FROM_PROJECT_EVENT':
      return _$gPullRequestTimelineItemsItemTypeREMOVED_FROM_PROJECT_EVENT;
    case 'RENAMED_TITLE_EVENT':
      return _$gPullRequestTimelineItemsItemTypeRENAMED_TITLE_EVENT;
    case 'REOPENED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeREOPENED_EVENT;
    case 'REVIEW_DISMISSED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeREVIEW_DISMISSED_EVENT;
    case 'REVIEW_REQUESTED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeREVIEW_REQUESTED_EVENT;
    case 'REVIEW_REQUEST_REMOVED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeREVIEW_REQUEST_REMOVED_EVENT;
    case 'SUBSCRIBED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeSUBSCRIBED_EVENT;
    case 'TRANSFERRED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeTRANSFERRED_EVENT;
    case 'UNASSIGNED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeUNASSIGNED_EVENT;
    case 'UNLABELED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeUNLABELED_EVENT;
    case 'UNLOCKED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeUNLOCKED_EVENT;
    case 'UNMARKED_AS_DUPLICATE_EVENT':
      return _$gPullRequestTimelineItemsItemTypeUNMARKED_AS_DUPLICATE_EVENT;
    case 'UNPINNED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeUNPINNED_EVENT;
    case 'UNSUBSCRIBED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeUNSUBSCRIBED_EVENT;
    case 'USER_BLOCKED_EVENT':
      return _$gPullRequestTimelineItemsItemTypeUSER_BLOCKED_EVENT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestTimelineItemsItemType>
    _$gPullRequestTimelineItemsItemTypeValues =
    new BuiltSet<GPullRequestTimelineItemsItemType>(const <
        GPullRequestTimelineItemsItemType>[
  _$gPullRequestTimelineItemsItemTypeADDED_TO_PROJECT_EVENT,
  _$gPullRequestTimelineItemsItemTypeASSIGNED_EVENT,
  _$gPullRequestTimelineItemsItemTypeAUTOMATIC_BASE_CHANGE_FAILED_EVENT,
  _$gPullRequestTimelineItemsItemTypeAUTOMATIC_BASE_CHANGE_SUCCEEDED_EVENT,
  _$gPullRequestTimelineItemsItemTypeAUTO_MERGE_DISABLED_EVENT,
  _$gPullRequestTimelineItemsItemTypeAUTO_MERGE_ENABLED_EVENT,
  _$gPullRequestTimelineItemsItemTypeAUTO_REBASE_ENABLED_EVENT,
  _$gPullRequestTimelineItemsItemTypeAUTO_SQUASH_ENABLED_EVENT,
  _$gPullRequestTimelineItemsItemTypeBASE_REF_CHANGED_EVENT,
  _$gPullRequestTimelineItemsItemTypeBASE_REF_DELETED_EVENT,
  _$gPullRequestTimelineItemsItemTypeBASE_REF_FORCE_PUSHED_EVENT,
  _$gPullRequestTimelineItemsItemTypeCLOSED_EVENT,
  _$gPullRequestTimelineItemsItemTypeCOMMENT_DELETED_EVENT,
  _$gPullRequestTimelineItemsItemTypeCONNECTED_EVENT,
  _$gPullRequestTimelineItemsItemTypeCONVERTED_NOTE_TO_ISSUE_EVENT,
  _$gPullRequestTimelineItemsItemTypeCONVERT_TO_DRAFT_EVENT,
  _$gPullRequestTimelineItemsItemTypeCROSS_REFERENCED_EVENT,
  _$gPullRequestTimelineItemsItemTypeDEMILESTONED_EVENT,
  _$gPullRequestTimelineItemsItemTypeDEPLOYED_EVENT,
  _$gPullRequestTimelineItemsItemTypeDEPLOYMENT_ENVIRONMENT_CHANGED_EVENT,
  _$gPullRequestTimelineItemsItemTypeDISCONNECTED_EVENT,
  _$gPullRequestTimelineItemsItemTypeHEAD_REF_DELETED_EVENT,
  _$gPullRequestTimelineItemsItemTypeHEAD_REF_FORCE_PUSHED_EVENT,
  _$gPullRequestTimelineItemsItemTypeHEAD_REF_RESTORED_EVENT,
  _$gPullRequestTimelineItemsItemTypeISSUE_COMMENT,
  _$gPullRequestTimelineItemsItemTypeLABELED_EVENT,
  _$gPullRequestTimelineItemsItemTypeLOCKED_EVENT,
  _$gPullRequestTimelineItemsItemTypeMARKED_AS_DUPLICATE_EVENT,
  _$gPullRequestTimelineItemsItemTypeMENTIONED_EVENT,
  _$gPullRequestTimelineItemsItemTypeMERGED_EVENT,
  _$gPullRequestTimelineItemsItemTypeMILESTONED_EVENT,
  _$gPullRequestTimelineItemsItemTypeMOVED_COLUMNS_IN_PROJECT_EVENT,
  _$gPullRequestTimelineItemsItemTypePINNED_EVENT,
  _$gPullRequestTimelineItemsItemTypePULL_REQUEST_COMMIT,
  _$gPullRequestTimelineItemsItemTypePULL_REQUEST_COMMIT_COMMENT_THREAD,
  _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVIEW,
  _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVIEW_THREAD,
  _$gPullRequestTimelineItemsItemTypePULL_REQUEST_REVISION_MARKER,
  _$gPullRequestTimelineItemsItemTypeREADY_FOR_REVIEW_EVENT,
  _$gPullRequestTimelineItemsItemTypeREFERENCED_EVENT,
  _$gPullRequestTimelineItemsItemTypeREMOVED_FROM_PROJECT_EVENT,
  _$gPullRequestTimelineItemsItemTypeRENAMED_TITLE_EVENT,
  _$gPullRequestTimelineItemsItemTypeREOPENED_EVENT,
  _$gPullRequestTimelineItemsItemTypeREVIEW_DISMISSED_EVENT,
  _$gPullRequestTimelineItemsItemTypeREVIEW_REQUESTED_EVENT,
  _$gPullRequestTimelineItemsItemTypeREVIEW_REQUEST_REMOVED_EVENT,
  _$gPullRequestTimelineItemsItemTypeSUBSCRIBED_EVENT,
  _$gPullRequestTimelineItemsItemTypeTRANSFERRED_EVENT,
  _$gPullRequestTimelineItemsItemTypeUNASSIGNED_EVENT,
  _$gPullRequestTimelineItemsItemTypeUNLABELED_EVENT,
  _$gPullRequestTimelineItemsItemTypeUNLOCKED_EVENT,
  _$gPullRequestTimelineItemsItemTypeUNMARKED_AS_DUPLICATE_EVENT,
  _$gPullRequestTimelineItemsItemTypeUNPINNED_EVENT,
  _$gPullRequestTimelineItemsItemTypeUNSUBSCRIBED_EVENT,
  _$gPullRequestTimelineItemsItemTypeUSER_BLOCKED_EVENT,
]);

const GPullRequestUpdateState _$gPullRequestUpdateStateCLOSED =
    const GPullRequestUpdateState._('CLOSED');
const GPullRequestUpdateState _$gPullRequestUpdateStateOPEN =
    const GPullRequestUpdateState._('OPEN');

GPullRequestUpdateState _$gPullRequestUpdateStateValueOf(String name) {
  switch (name) {
    case 'CLOSED':
      return _$gPullRequestUpdateStateCLOSED;
    case 'OPEN':
      return _$gPullRequestUpdateStateOPEN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GPullRequestUpdateState> _$gPullRequestUpdateStateValues =
    new BuiltSet<GPullRequestUpdateState>(const <GPullRequestUpdateState>[
  _$gPullRequestUpdateStateCLOSED,
  _$gPullRequestUpdateStateOPEN,
]);

const GReactionContent _$gReactionContentCONFUSED =
    const GReactionContent._('CONFUSED');
const GReactionContent _$gReactionContentEYES =
    const GReactionContent._('EYES');
const GReactionContent _$gReactionContentHEART =
    const GReactionContent._('HEART');
const GReactionContent _$gReactionContentHOORAY =
    const GReactionContent._('HOORAY');
const GReactionContent _$gReactionContentLAUGH =
    const GReactionContent._('LAUGH');
const GReactionContent _$gReactionContentROCKET =
    const GReactionContent._('ROCKET');
const GReactionContent _$gReactionContentTHUMBS_DOWN =
    const GReactionContent._('THUMBS_DOWN');
const GReactionContent _$gReactionContentTHUMBS_UP =
    const GReactionContent._('THUMBS_UP');

GReactionContent _$gReactionContentValueOf(String name) {
  switch (name) {
    case 'CONFUSED':
      return _$gReactionContentCONFUSED;
    case 'EYES':
      return _$gReactionContentEYES;
    case 'HEART':
      return _$gReactionContentHEART;
    case 'HOORAY':
      return _$gReactionContentHOORAY;
    case 'LAUGH':
      return _$gReactionContentLAUGH;
    case 'ROCKET':
      return _$gReactionContentROCKET;
    case 'THUMBS_DOWN':
      return _$gReactionContentTHUMBS_DOWN;
    case 'THUMBS_UP':
      return _$gReactionContentTHUMBS_UP;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GReactionContent> _$gReactionContentValues =
    new BuiltSet<GReactionContent>(const <GReactionContent>[
  _$gReactionContentCONFUSED,
  _$gReactionContentEYES,
  _$gReactionContentHEART,
  _$gReactionContentHOORAY,
  _$gReactionContentLAUGH,
  _$gReactionContentROCKET,
  _$gReactionContentTHUMBS_DOWN,
  _$gReactionContentTHUMBS_UP,
]);

const GReactionOrderField _$gReactionOrderFieldCREATED_AT =
    const GReactionOrderField._('CREATED_AT');

GReactionOrderField _$gReactionOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gReactionOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GReactionOrderField> _$gReactionOrderFieldValues =
    new BuiltSet<GReactionOrderField>(const <GReactionOrderField>[
  _$gReactionOrderFieldCREATED_AT,
]);

const GRefOrderField _$gRefOrderFieldALPHABETICAL =
    const GRefOrderField._('ALPHABETICAL');
const GRefOrderField _$gRefOrderFieldTAG_COMMIT_DATE =
    const GRefOrderField._('TAG_COMMIT_DATE');

GRefOrderField _$gRefOrderFieldValueOf(String name) {
  switch (name) {
    case 'ALPHABETICAL':
      return _$gRefOrderFieldALPHABETICAL;
    case 'TAG_COMMIT_DATE':
      return _$gRefOrderFieldTAG_COMMIT_DATE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRefOrderField> _$gRefOrderFieldValues =
    new BuiltSet<GRefOrderField>(const <GRefOrderField>[
  _$gRefOrderFieldALPHABETICAL,
  _$gRefOrderFieldTAG_COMMIT_DATE,
]);

const GReleaseOrderField _$gReleaseOrderFieldCREATED_AT =
    const GReleaseOrderField._('CREATED_AT');
const GReleaseOrderField _$gReleaseOrderFieldNAME =
    const GReleaseOrderField._('NAME');

GReleaseOrderField _$gReleaseOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gReleaseOrderFieldCREATED_AT;
    case 'NAME':
      return _$gReleaseOrderFieldNAME;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GReleaseOrderField> _$gReleaseOrderFieldValues =
    new BuiltSet<GReleaseOrderField>(const <GReleaseOrderField>[
  _$gReleaseOrderFieldCREATED_AT,
  _$gReleaseOrderFieldNAME,
]);

const GRepoAccessAuditEntryVisibility
    _$gRepoAccessAuditEntryVisibilityINTERNAL =
    const GRepoAccessAuditEntryVisibility._('INTERNAL');
const GRepoAccessAuditEntryVisibility _$gRepoAccessAuditEntryVisibilityPRIVATE =
    const GRepoAccessAuditEntryVisibility._('PRIVATE');
const GRepoAccessAuditEntryVisibility _$gRepoAccessAuditEntryVisibilityPUBLIC =
    const GRepoAccessAuditEntryVisibility._('PUBLIC');

GRepoAccessAuditEntryVisibility _$gRepoAccessAuditEntryVisibilityValueOf(
    String name) {
  switch (name) {
    case 'INTERNAL':
      return _$gRepoAccessAuditEntryVisibilityINTERNAL;
    case 'PRIVATE':
      return _$gRepoAccessAuditEntryVisibilityPRIVATE;
    case 'PUBLIC':
      return _$gRepoAccessAuditEntryVisibilityPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepoAccessAuditEntryVisibility>
    _$gRepoAccessAuditEntryVisibilityValues =
    new BuiltSet<GRepoAccessAuditEntryVisibility>(const <
        GRepoAccessAuditEntryVisibility>[
  _$gRepoAccessAuditEntryVisibilityINTERNAL,
  _$gRepoAccessAuditEntryVisibilityPRIVATE,
  _$gRepoAccessAuditEntryVisibilityPUBLIC,
]);

const GRepoAddMemberAuditEntryVisibility
    _$gRepoAddMemberAuditEntryVisibilityINTERNAL =
    const GRepoAddMemberAuditEntryVisibility._('INTERNAL');
const GRepoAddMemberAuditEntryVisibility
    _$gRepoAddMemberAuditEntryVisibilityPRIVATE =
    const GRepoAddMemberAuditEntryVisibility._('PRIVATE');
const GRepoAddMemberAuditEntryVisibility
    _$gRepoAddMemberAuditEntryVisibilityPUBLIC =
    const GRepoAddMemberAuditEntryVisibility._('PUBLIC');

GRepoAddMemberAuditEntryVisibility _$gRepoAddMemberAuditEntryVisibilityValueOf(
    String name) {
  switch (name) {
    case 'INTERNAL':
      return _$gRepoAddMemberAuditEntryVisibilityINTERNAL;
    case 'PRIVATE':
      return _$gRepoAddMemberAuditEntryVisibilityPRIVATE;
    case 'PUBLIC':
      return _$gRepoAddMemberAuditEntryVisibilityPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepoAddMemberAuditEntryVisibility>
    _$gRepoAddMemberAuditEntryVisibilityValues =
    new BuiltSet<GRepoAddMemberAuditEntryVisibility>(const <
        GRepoAddMemberAuditEntryVisibility>[
  _$gRepoAddMemberAuditEntryVisibilityINTERNAL,
  _$gRepoAddMemberAuditEntryVisibilityPRIVATE,
  _$gRepoAddMemberAuditEntryVisibilityPUBLIC,
]);

const GRepoArchivedAuditEntryVisibility
    _$gRepoArchivedAuditEntryVisibilityINTERNAL =
    const GRepoArchivedAuditEntryVisibility._('INTERNAL');
const GRepoArchivedAuditEntryVisibility
    _$gRepoArchivedAuditEntryVisibilityPRIVATE =
    const GRepoArchivedAuditEntryVisibility._('PRIVATE');
const GRepoArchivedAuditEntryVisibility
    _$gRepoArchivedAuditEntryVisibilityPUBLIC =
    const GRepoArchivedAuditEntryVisibility._('PUBLIC');

GRepoArchivedAuditEntryVisibility _$gRepoArchivedAuditEntryVisibilityValueOf(
    String name) {
  switch (name) {
    case 'INTERNAL':
      return _$gRepoArchivedAuditEntryVisibilityINTERNAL;
    case 'PRIVATE':
      return _$gRepoArchivedAuditEntryVisibilityPRIVATE;
    case 'PUBLIC':
      return _$gRepoArchivedAuditEntryVisibilityPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepoArchivedAuditEntryVisibility>
    _$gRepoArchivedAuditEntryVisibilityValues =
    new BuiltSet<GRepoArchivedAuditEntryVisibility>(const <
        GRepoArchivedAuditEntryVisibility>[
  _$gRepoArchivedAuditEntryVisibilityINTERNAL,
  _$gRepoArchivedAuditEntryVisibilityPRIVATE,
  _$gRepoArchivedAuditEntryVisibilityPUBLIC,
]);

const GRepoChangeMergeSettingAuditEntryMergeType
    _$gRepoChangeMergeSettingAuditEntryMergeTypeMERGE =
    const GRepoChangeMergeSettingAuditEntryMergeType._('MERGE');
const GRepoChangeMergeSettingAuditEntryMergeType
    _$gRepoChangeMergeSettingAuditEntryMergeTypeREBASE =
    const GRepoChangeMergeSettingAuditEntryMergeType._('REBASE');
const GRepoChangeMergeSettingAuditEntryMergeType
    _$gRepoChangeMergeSettingAuditEntryMergeTypeSQUASH =
    const GRepoChangeMergeSettingAuditEntryMergeType._('SQUASH');

GRepoChangeMergeSettingAuditEntryMergeType
    _$gRepoChangeMergeSettingAuditEntryMergeTypeValueOf(String name) {
  switch (name) {
    case 'MERGE':
      return _$gRepoChangeMergeSettingAuditEntryMergeTypeMERGE;
    case 'REBASE':
      return _$gRepoChangeMergeSettingAuditEntryMergeTypeREBASE;
    case 'SQUASH':
      return _$gRepoChangeMergeSettingAuditEntryMergeTypeSQUASH;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepoChangeMergeSettingAuditEntryMergeType>
    _$gRepoChangeMergeSettingAuditEntryMergeTypeValues =
    new BuiltSet<GRepoChangeMergeSettingAuditEntryMergeType>(const <
        GRepoChangeMergeSettingAuditEntryMergeType>[
  _$gRepoChangeMergeSettingAuditEntryMergeTypeMERGE,
  _$gRepoChangeMergeSettingAuditEntryMergeTypeREBASE,
  _$gRepoChangeMergeSettingAuditEntryMergeTypeSQUASH,
]);

const GRepoCreateAuditEntryVisibility
    _$gRepoCreateAuditEntryVisibilityINTERNAL =
    const GRepoCreateAuditEntryVisibility._('INTERNAL');
const GRepoCreateAuditEntryVisibility _$gRepoCreateAuditEntryVisibilityPRIVATE =
    const GRepoCreateAuditEntryVisibility._('PRIVATE');
const GRepoCreateAuditEntryVisibility _$gRepoCreateAuditEntryVisibilityPUBLIC =
    const GRepoCreateAuditEntryVisibility._('PUBLIC');

GRepoCreateAuditEntryVisibility _$gRepoCreateAuditEntryVisibilityValueOf(
    String name) {
  switch (name) {
    case 'INTERNAL':
      return _$gRepoCreateAuditEntryVisibilityINTERNAL;
    case 'PRIVATE':
      return _$gRepoCreateAuditEntryVisibilityPRIVATE;
    case 'PUBLIC':
      return _$gRepoCreateAuditEntryVisibilityPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepoCreateAuditEntryVisibility>
    _$gRepoCreateAuditEntryVisibilityValues =
    new BuiltSet<GRepoCreateAuditEntryVisibility>(const <
        GRepoCreateAuditEntryVisibility>[
  _$gRepoCreateAuditEntryVisibilityINTERNAL,
  _$gRepoCreateAuditEntryVisibilityPRIVATE,
  _$gRepoCreateAuditEntryVisibilityPUBLIC,
]);

const GRepoDestroyAuditEntryVisibility
    _$gRepoDestroyAuditEntryVisibilityINTERNAL =
    const GRepoDestroyAuditEntryVisibility._('INTERNAL');
const GRepoDestroyAuditEntryVisibility
    _$gRepoDestroyAuditEntryVisibilityPRIVATE =
    const GRepoDestroyAuditEntryVisibility._('PRIVATE');
const GRepoDestroyAuditEntryVisibility
    _$gRepoDestroyAuditEntryVisibilityPUBLIC =
    const GRepoDestroyAuditEntryVisibility._('PUBLIC');

GRepoDestroyAuditEntryVisibility _$gRepoDestroyAuditEntryVisibilityValueOf(
    String name) {
  switch (name) {
    case 'INTERNAL':
      return _$gRepoDestroyAuditEntryVisibilityINTERNAL;
    case 'PRIVATE':
      return _$gRepoDestroyAuditEntryVisibilityPRIVATE;
    case 'PUBLIC':
      return _$gRepoDestroyAuditEntryVisibilityPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepoDestroyAuditEntryVisibility>
    _$gRepoDestroyAuditEntryVisibilityValues =
    new BuiltSet<GRepoDestroyAuditEntryVisibility>(const <
        GRepoDestroyAuditEntryVisibility>[
  _$gRepoDestroyAuditEntryVisibilityINTERNAL,
  _$gRepoDestroyAuditEntryVisibilityPRIVATE,
  _$gRepoDestroyAuditEntryVisibilityPUBLIC,
]);

const GRepoRemoveMemberAuditEntryVisibility
    _$gRepoRemoveMemberAuditEntryVisibilityINTERNAL =
    const GRepoRemoveMemberAuditEntryVisibility._('INTERNAL');
const GRepoRemoveMemberAuditEntryVisibility
    _$gRepoRemoveMemberAuditEntryVisibilityPRIVATE =
    const GRepoRemoveMemberAuditEntryVisibility._('PRIVATE');
const GRepoRemoveMemberAuditEntryVisibility
    _$gRepoRemoveMemberAuditEntryVisibilityPUBLIC =
    const GRepoRemoveMemberAuditEntryVisibility._('PUBLIC');

GRepoRemoveMemberAuditEntryVisibility
    _$gRepoRemoveMemberAuditEntryVisibilityValueOf(String name) {
  switch (name) {
    case 'INTERNAL':
      return _$gRepoRemoveMemberAuditEntryVisibilityINTERNAL;
    case 'PRIVATE':
      return _$gRepoRemoveMemberAuditEntryVisibilityPRIVATE;
    case 'PUBLIC':
      return _$gRepoRemoveMemberAuditEntryVisibilityPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepoRemoveMemberAuditEntryVisibility>
    _$gRepoRemoveMemberAuditEntryVisibilityValues =
    new BuiltSet<GRepoRemoveMemberAuditEntryVisibility>(const <
        GRepoRemoveMemberAuditEntryVisibility>[
  _$gRepoRemoveMemberAuditEntryVisibilityINTERNAL,
  _$gRepoRemoveMemberAuditEntryVisibilityPRIVATE,
  _$gRepoRemoveMemberAuditEntryVisibilityPUBLIC,
]);

const GReportedContentClassifiers _$gReportedContentClassifiersABUSE =
    const GReportedContentClassifiers._('ABUSE');
const GReportedContentClassifiers _$gReportedContentClassifiersDUPLICATE =
    const GReportedContentClassifiers._('DUPLICATE');
const GReportedContentClassifiers _$gReportedContentClassifiersOFF_TOPIC =
    const GReportedContentClassifiers._('OFF_TOPIC');
const GReportedContentClassifiers _$gReportedContentClassifiersOUTDATED =
    const GReportedContentClassifiers._('OUTDATED');
const GReportedContentClassifiers _$gReportedContentClassifiersRESOLVED =
    const GReportedContentClassifiers._('RESOLVED');
const GReportedContentClassifiers _$gReportedContentClassifiersSPAM =
    const GReportedContentClassifiers._('SPAM');

GReportedContentClassifiers _$gReportedContentClassifiersValueOf(String name) {
  switch (name) {
    case 'ABUSE':
      return _$gReportedContentClassifiersABUSE;
    case 'DUPLICATE':
      return _$gReportedContentClassifiersDUPLICATE;
    case 'OFF_TOPIC':
      return _$gReportedContentClassifiersOFF_TOPIC;
    case 'OUTDATED':
      return _$gReportedContentClassifiersOUTDATED;
    case 'RESOLVED':
      return _$gReportedContentClassifiersRESOLVED;
    case 'SPAM':
      return _$gReportedContentClassifiersSPAM;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GReportedContentClassifiers>
    _$gReportedContentClassifiersValues = new BuiltSet<
        GReportedContentClassifiers>(const <GReportedContentClassifiers>[
  _$gReportedContentClassifiersABUSE,
  _$gReportedContentClassifiersDUPLICATE,
  _$gReportedContentClassifiersOFF_TOPIC,
  _$gReportedContentClassifiersOUTDATED,
  _$gReportedContentClassifiersRESOLVED,
  _$gReportedContentClassifiersSPAM,
]);

const GRepositoryAffiliation _$gRepositoryAffiliationCOLLABORATOR =
    const GRepositoryAffiliation._('COLLABORATOR');
const GRepositoryAffiliation _$gRepositoryAffiliationORGANIZATION_MEMBER =
    const GRepositoryAffiliation._('ORGANIZATION_MEMBER');
const GRepositoryAffiliation _$gRepositoryAffiliationOWNER =
    const GRepositoryAffiliation._('OWNER');

GRepositoryAffiliation _$gRepositoryAffiliationValueOf(String name) {
  switch (name) {
    case 'COLLABORATOR':
      return _$gRepositoryAffiliationCOLLABORATOR;
    case 'ORGANIZATION_MEMBER':
      return _$gRepositoryAffiliationORGANIZATION_MEMBER;
    case 'OWNER':
      return _$gRepositoryAffiliationOWNER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryAffiliation> _$gRepositoryAffiliationValues =
    new BuiltSet<GRepositoryAffiliation>(const <GRepositoryAffiliation>[
  _$gRepositoryAffiliationCOLLABORATOR,
  _$gRepositoryAffiliationORGANIZATION_MEMBER,
  _$gRepositoryAffiliationOWNER,
]);

const GRepositoryContributionType _$gRepositoryContributionTypeCOMMIT =
    const GRepositoryContributionType._('COMMIT');
const GRepositoryContributionType _$gRepositoryContributionTypeISSUE =
    const GRepositoryContributionType._('ISSUE');
const GRepositoryContributionType _$gRepositoryContributionTypePULL_REQUEST =
    const GRepositoryContributionType._('PULL_REQUEST');
const GRepositoryContributionType
    _$gRepositoryContributionTypePULL_REQUEST_REVIEW =
    const GRepositoryContributionType._('PULL_REQUEST_REVIEW');
const GRepositoryContributionType _$gRepositoryContributionTypeREPOSITORY =
    const GRepositoryContributionType._('REPOSITORY');

GRepositoryContributionType _$gRepositoryContributionTypeValueOf(String name) {
  switch (name) {
    case 'COMMIT':
      return _$gRepositoryContributionTypeCOMMIT;
    case 'ISSUE':
      return _$gRepositoryContributionTypeISSUE;
    case 'PULL_REQUEST':
      return _$gRepositoryContributionTypePULL_REQUEST;
    case 'PULL_REQUEST_REVIEW':
      return _$gRepositoryContributionTypePULL_REQUEST_REVIEW;
    case 'REPOSITORY':
      return _$gRepositoryContributionTypeREPOSITORY;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryContributionType>
    _$gRepositoryContributionTypeValues = new BuiltSet<
        GRepositoryContributionType>(const <GRepositoryContributionType>[
  _$gRepositoryContributionTypeCOMMIT,
  _$gRepositoryContributionTypeISSUE,
  _$gRepositoryContributionTypePULL_REQUEST,
  _$gRepositoryContributionTypePULL_REQUEST_REVIEW,
  _$gRepositoryContributionTypeREPOSITORY,
]);

const GRepositoryInteractionLimit
    _$gRepositoryInteractionLimitCOLLABORATORS_ONLY =
    const GRepositoryInteractionLimit._('COLLABORATORS_ONLY');
const GRepositoryInteractionLimit
    _$gRepositoryInteractionLimitCONTRIBUTORS_ONLY =
    const GRepositoryInteractionLimit._('CONTRIBUTORS_ONLY');
const GRepositoryInteractionLimit _$gRepositoryInteractionLimitEXISTING_USERS =
    const GRepositoryInteractionLimit._('EXISTING_USERS');
const GRepositoryInteractionLimit _$gRepositoryInteractionLimitNO_LIMIT =
    const GRepositoryInteractionLimit._('NO_LIMIT');

GRepositoryInteractionLimit _$gRepositoryInteractionLimitValueOf(String name) {
  switch (name) {
    case 'COLLABORATORS_ONLY':
      return _$gRepositoryInteractionLimitCOLLABORATORS_ONLY;
    case 'CONTRIBUTORS_ONLY':
      return _$gRepositoryInteractionLimitCONTRIBUTORS_ONLY;
    case 'EXISTING_USERS':
      return _$gRepositoryInteractionLimitEXISTING_USERS;
    case 'NO_LIMIT':
      return _$gRepositoryInteractionLimitNO_LIMIT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryInteractionLimit>
    _$gRepositoryInteractionLimitValues = new BuiltSet<
        GRepositoryInteractionLimit>(const <GRepositoryInteractionLimit>[
  _$gRepositoryInteractionLimitCOLLABORATORS_ONLY,
  _$gRepositoryInteractionLimitCONTRIBUTORS_ONLY,
  _$gRepositoryInteractionLimitEXISTING_USERS,
  _$gRepositoryInteractionLimitNO_LIMIT,
]);

const GRepositoryInteractionLimitExpiry
    _$gRepositoryInteractionLimitExpiryONE_DAY =
    const GRepositoryInteractionLimitExpiry._('ONE_DAY');
const GRepositoryInteractionLimitExpiry
    _$gRepositoryInteractionLimitExpiryONE_MONTH =
    const GRepositoryInteractionLimitExpiry._('ONE_MONTH');
const GRepositoryInteractionLimitExpiry
    _$gRepositoryInteractionLimitExpiryONE_WEEK =
    const GRepositoryInteractionLimitExpiry._('ONE_WEEK');
const GRepositoryInteractionLimitExpiry
    _$gRepositoryInteractionLimitExpirySIX_MONTHS =
    const GRepositoryInteractionLimitExpiry._('SIX_MONTHS');
const GRepositoryInteractionLimitExpiry
    _$gRepositoryInteractionLimitExpiryTHREE_DAYS =
    const GRepositoryInteractionLimitExpiry._('THREE_DAYS');

GRepositoryInteractionLimitExpiry _$gRepositoryInteractionLimitExpiryValueOf(
    String name) {
  switch (name) {
    case 'ONE_DAY':
      return _$gRepositoryInteractionLimitExpiryONE_DAY;
    case 'ONE_MONTH':
      return _$gRepositoryInteractionLimitExpiryONE_MONTH;
    case 'ONE_WEEK':
      return _$gRepositoryInteractionLimitExpiryONE_WEEK;
    case 'SIX_MONTHS':
      return _$gRepositoryInteractionLimitExpirySIX_MONTHS;
    case 'THREE_DAYS':
      return _$gRepositoryInteractionLimitExpiryTHREE_DAYS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryInteractionLimitExpiry>
    _$gRepositoryInteractionLimitExpiryValues =
    new BuiltSet<GRepositoryInteractionLimitExpiry>(const <
        GRepositoryInteractionLimitExpiry>[
  _$gRepositoryInteractionLimitExpiryONE_DAY,
  _$gRepositoryInteractionLimitExpiryONE_MONTH,
  _$gRepositoryInteractionLimitExpiryONE_WEEK,
  _$gRepositoryInteractionLimitExpirySIX_MONTHS,
  _$gRepositoryInteractionLimitExpiryTHREE_DAYS,
]);

const GRepositoryInteractionLimitOrigin
    _$gRepositoryInteractionLimitOriginORGANIZATION =
    const GRepositoryInteractionLimitOrigin._('ORGANIZATION');
const GRepositoryInteractionLimitOrigin
    _$gRepositoryInteractionLimitOriginREPOSITORY =
    const GRepositoryInteractionLimitOrigin._('REPOSITORY');
const GRepositoryInteractionLimitOrigin
    _$gRepositoryInteractionLimitOriginUSER =
    const GRepositoryInteractionLimitOrigin._('USER');

GRepositoryInteractionLimitOrigin _$gRepositoryInteractionLimitOriginValueOf(
    String name) {
  switch (name) {
    case 'ORGANIZATION':
      return _$gRepositoryInteractionLimitOriginORGANIZATION;
    case 'REPOSITORY':
      return _$gRepositoryInteractionLimitOriginREPOSITORY;
    case 'USER':
      return _$gRepositoryInteractionLimitOriginUSER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryInteractionLimitOrigin>
    _$gRepositoryInteractionLimitOriginValues =
    new BuiltSet<GRepositoryInteractionLimitOrigin>(const <
        GRepositoryInteractionLimitOrigin>[
  _$gRepositoryInteractionLimitOriginORGANIZATION,
  _$gRepositoryInteractionLimitOriginREPOSITORY,
  _$gRepositoryInteractionLimitOriginUSER,
]);

const GRepositoryInvitationOrderField
    _$gRepositoryInvitationOrderFieldCREATED_AT =
    const GRepositoryInvitationOrderField._('CREATED_AT');
const GRepositoryInvitationOrderField
    _$gRepositoryInvitationOrderFieldINVITEE_LOGIN =
    const GRepositoryInvitationOrderField._('INVITEE_LOGIN');

GRepositoryInvitationOrderField _$gRepositoryInvitationOrderFieldValueOf(
    String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gRepositoryInvitationOrderFieldCREATED_AT;
    case 'INVITEE_LOGIN':
      return _$gRepositoryInvitationOrderFieldINVITEE_LOGIN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryInvitationOrderField>
    _$gRepositoryInvitationOrderFieldValues =
    new BuiltSet<GRepositoryInvitationOrderField>(const <
        GRepositoryInvitationOrderField>[
  _$gRepositoryInvitationOrderFieldCREATED_AT,
  _$gRepositoryInvitationOrderFieldINVITEE_LOGIN,
]);

const GRepositoryLockReason _$gRepositoryLockReasonBILLING =
    const GRepositoryLockReason._('BILLING');
const GRepositoryLockReason _$gRepositoryLockReasonMIGRATING =
    const GRepositoryLockReason._('MIGRATING');
const GRepositoryLockReason _$gRepositoryLockReasonMOVING =
    const GRepositoryLockReason._('MOVING');
const GRepositoryLockReason _$gRepositoryLockReasonRENAME =
    const GRepositoryLockReason._('RENAME');

GRepositoryLockReason _$gRepositoryLockReasonValueOf(String name) {
  switch (name) {
    case 'BILLING':
      return _$gRepositoryLockReasonBILLING;
    case 'MIGRATING':
      return _$gRepositoryLockReasonMIGRATING;
    case 'MOVING':
      return _$gRepositoryLockReasonMOVING;
    case 'RENAME':
      return _$gRepositoryLockReasonRENAME;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryLockReason> _$gRepositoryLockReasonValues =
    new BuiltSet<GRepositoryLockReason>(const <GRepositoryLockReason>[
  _$gRepositoryLockReasonBILLING,
  _$gRepositoryLockReasonMIGRATING,
  _$gRepositoryLockReasonMOVING,
  _$gRepositoryLockReasonRENAME,
]);

const GRepositoryOrderField _$gRepositoryOrderFieldCREATED_AT =
    const GRepositoryOrderField._('CREATED_AT');
const GRepositoryOrderField _$gRepositoryOrderFieldNAME =
    const GRepositoryOrderField._('NAME');
const GRepositoryOrderField _$gRepositoryOrderFieldPUSHED_AT =
    const GRepositoryOrderField._('PUSHED_AT');
const GRepositoryOrderField _$gRepositoryOrderFieldSTARGAZERS =
    const GRepositoryOrderField._('STARGAZERS');
const GRepositoryOrderField _$gRepositoryOrderFieldUPDATED_AT =
    const GRepositoryOrderField._('UPDATED_AT');

GRepositoryOrderField _$gRepositoryOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gRepositoryOrderFieldCREATED_AT;
    case 'NAME':
      return _$gRepositoryOrderFieldNAME;
    case 'PUSHED_AT':
      return _$gRepositoryOrderFieldPUSHED_AT;
    case 'STARGAZERS':
      return _$gRepositoryOrderFieldSTARGAZERS;
    case 'UPDATED_AT':
      return _$gRepositoryOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryOrderField> _$gRepositoryOrderFieldValues =
    new BuiltSet<GRepositoryOrderField>(const <GRepositoryOrderField>[
  _$gRepositoryOrderFieldCREATED_AT,
  _$gRepositoryOrderFieldNAME,
  _$gRepositoryOrderFieldPUSHED_AT,
  _$gRepositoryOrderFieldSTARGAZERS,
  _$gRepositoryOrderFieldUPDATED_AT,
]);

const GRepositoryPermission _$gRepositoryPermissionADMIN =
    const GRepositoryPermission._('ADMIN');
const GRepositoryPermission _$gRepositoryPermissionMAINTAIN =
    const GRepositoryPermission._('MAINTAIN');
const GRepositoryPermission _$gRepositoryPermissionREAD =
    const GRepositoryPermission._('READ');
const GRepositoryPermission _$gRepositoryPermissionTRIAGE =
    const GRepositoryPermission._('TRIAGE');
const GRepositoryPermission _$gRepositoryPermissionWRITE =
    const GRepositoryPermission._('WRITE');

GRepositoryPermission _$gRepositoryPermissionValueOf(String name) {
  switch (name) {
    case 'ADMIN':
      return _$gRepositoryPermissionADMIN;
    case 'MAINTAIN':
      return _$gRepositoryPermissionMAINTAIN;
    case 'READ':
      return _$gRepositoryPermissionREAD;
    case 'TRIAGE':
      return _$gRepositoryPermissionTRIAGE;
    case 'WRITE':
      return _$gRepositoryPermissionWRITE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryPermission> _$gRepositoryPermissionValues =
    new BuiltSet<GRepositoryPermission>(const <GRepositoryPermission>[
  _$gRepositoryPermissionADMIN,
  _$gRepositoryPermissionMAINTAIN,
  _$gRepositoryPermissionREAD,
  _$gRepositoryPermissionTRIAGE,
  _$gRepositoryPermissionWRITE,
]);

const GRepositoryPrivacy _$gRepositoryPrivacyPRIVATE =
    const GRepositoryPrivacy._('PRIVATE');
const GRepositoryPrivacy _$gRepositoryPrivacyPUBLIC =
    const GRepositoryPrivacy._('PUBLIC');

GRepositoryPrivacy _$gRepositoryPrivacyValueOf(String name) {
  switch (name) {
    case 'PRIVATE':
      return _$gRepositoryPrivacyPRIVATE;
    case 'PUBLIC':
      return _$gRepositoryPrivacyPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryPrivacy> _$gRepositoryPrivacyValues =
    new BuiltSet<GRepositoryPrivacy>(const <GRepositoryPrivacy>[
  _$gRepositoryPrivacyPRIVATE,
  _$gRepositoryPrivacyPUBLIC,
]);

const GRepositoryVisibility _$gRepositoryVisibilityINTERNAL =
    const GRepositoryVisibility._('INTERNAL');
const GRepositoryVisibility _$gRepositoryVisibilityPRIVATE =
    const GRepositoryVisibility._('PRIVATE');
const GRepositoryVisibility _$gRepositoryVisibilityPUBLIC =
    const GRepositoryVisibility._('PUBLIC');

GRepositoryVisibility _$gRepositoryVisibilityValueOf(String name) {
  switch (name) {
    case 'INTERNAL':
      return _$gRepositoryVisibilityINTERNAL;
    case 'PRIVATE':
      return _$gRepositoryVisibilityPRIVATE;
    case 'PUBLIC':
      return _$gRepositoryVisibilityPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRepositoryVisibility> _$gRepositoryVisibilityValues =
    new BuiltSet<GRepositoryVisibility>(const <GRepositoryVisibility>[
  _$gRepositoryVisibilityINTERNAL,
  _$gRepositoryVisibilityPRIVATE,
  _$gRepositoryVisibilityPUBLIC,
]);

const GRequestableCheckStatusState _$gRequestableCheckStatusStateCOMPLETED =
    const GRequestableCheckStatusState._('COMPLETED');
const GRequestableCheckStatusState _$gRequestableCheckStatusStateIN_PROGRESS =
    const GRequestableCheckStatusState._('IN_PROGRESS');
const GRequestableCheckStatusState _$gRequestableCheckStatusStatePENDING =
    const GRequestableCheckStatusState._('PENDING');
const GRequestableCheckStatusState _$gRequestableCheckStatusStateQUEUED =
    const GRequestableCheckStatusState._('QUEUED');
const GRequestableCheckStatusState _$gRequestableCheckStatusStateWAITING =
    const GRequestableCheckStatusState._('WAITING');

GRequestableCheckStatusState _$gRequestableCheckStatusStateValueOf(
    String name) {
  switch (name) {
    case 'COMPLETED':
      return _$gRequestableCheckStatusStateCOMPLETED;
    case 'IN_PROGRESS':
      return _$gRequestableCheckStatusStateIN_PROGRESS;
    case 'PENDING':
      return _$gRequestableCheckStatusStatePENDING;
    case 'QUEUED':
      return _$gRequestableCheckStatusStateQUEUED;
    case 'WAITING':
      return _$gRequestableCheckStatusStateWAITING;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRequestableCheckStatusState>
    _$gRequestableCheckStatusStateValues = new BuiltSet<
        GRequestableCheckStatusState>(const <GRequestableCheckStatusState>[
  _$gRequestableCheckStatusStateCOMPLETED,
  _$gRequestableCheckStatusStateIN_PROGRESS,
  _$gRequestableCheckStatusStatePENDING,
  _$gRequestableCheckStatusStateQUEUED,
  _$gRequestableCheckStatusStateWAITING,
]);

const GSamlDigestAlgorithm _$gSamlDigestAlgorithmSHA1 =
    const GSamlDigestAlgorithm._('SHA1');
const GSamlDigestAlgorithm _$gSamlDigestAlgorithmSHA256 =
    const GSamlDigestAlgorithm._('SHA256');
const GSamlDigestAlgorithm _$gSamlDigestAlgorithmSHA384 =
    const GSamlDigestAlgorithm._('SHA384');
const GSamlDigestAlgorithm _$gSamlDigestAlgorithmSHA512 =
    const GSamlDigestAlgorithm._('SHA512');

GSamlDigestAlgorithm _$gSamlDigestAlgorithmValueOf(String name) {
  switch (name) {
    case 'SHA1':
      return _$gSamlDigestAlgorithmSHA1;
    case 'SHA256':
      return _$gSamlDigestAlgorithmSHA256;
    case 'SHA384':
      return _$gSamlDigestAlgorithmSHA384;
    case 'SHA512':
      return _$gSamlDigestAlgorithmSHA512;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSamlDigestAlgorithm> _$gSamlDigestAlgorithmValues =
    new BuiltSet<GSamlDigestAlgorithm>(const <GSamlDigestAlgorithm>[
  _$gSamlDigestAlgorithmSHA1,
  _$gSamlDigestAlgorithmSHA256,
  _$gSamlDigestAlgorithmSHA384,
  _$gSamlDigestAlgorithmSHA512,
]);

const GSamlSignatureAlgorithm _$gSamlSignatureAlgorithmRSA_SHA1 =
    const GSamlSignatureAlgorithm._('RSA_SHA1');
const GSamlSignatureAlgorithm _$gSamlSignatureAlgorithmRSA_SHA256 =
    const GSamlSignatureAlgorithm._('RSA_SHA256');
const GSamlSignatureAlgorithm _$gSamlSignatureAlgorithmRSA_SHA384 =
    const GSamlSignatureAlgorithm._('RSA_SHA384');
const GSamlSignatureAlgorithm _$gSamlSignatureAlgorithmRSA_SHA512 =
    const GSamlSignatureAlgorithm._('RSA_SHA512');

GSamlSignatureAlgorithm _$gSamlSignatureAlgorithmValueOf(String name) {
  switch (name) {
    case 'RSA_SHA1':
      return _$gSamlSignatureAlgorithmRSA_SHA1;
    case 'RSA_SHA256':
      return _$gSamlSignatureAlgorithmRSA_SHA256;
    case 'RSA_SHA384':
      return _$gSamlSignatureAlgorithmRSA_SHA384;
    case 'RSA_SHA512':
      return _$gSamlSignatureAlgorithmRSA_SHA512;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSamlSignatureAlgorithm> _$gSamlSignatureAlgorithmValues =
    new BuiltSet<GSamlSignatureAlgorithm>(const <GSamlSignatureAlgorithm>[
  _$gSamlSignatureAlgorithmRSA_SHA1,
  _$gSamlSignatureAlgorithmRSA_SHA256,
  _$gSamlSignatureAlgorithmRSA_SHA384,
  _$gSamlSignatureAlgorithmRSA_SHA512,
]);

const GSavedReplyOrderField _$gSavedReplyOrderFieldUPDATED_AT =
    const GSavedReplyOrderField._('UPDATED_AT');

GSavedReplyOrderField _$gSavedReplyOrderFieldValueOf(String name) {
  switch (name) {
    case 'UPDATED_AT':
      return _$gSavedReplyOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSavedReplyOrderField> _$gSavedReplyOrderFieldValues =
    new BuiltSet<GSavedReplyOrderField>(const <GSavedReplyOrderField>[
  _$gSavedReplyOrderFieldUPDATED_AT,
]);

const GSearchType _$gSearchTypeDISCUSSION = const GSearchType._('DISCUSSION');
const GSearchType _$gSearchTypeISSUE = const GSearchType._('ISSUE');
const GSearchType _$gSearchTypeREPOSITORY = const GSearchType._('REPOSITORY');
const GSearchType _$gSearchTypeUSER = const GSearchType._('USER');

GSearchType _$gSearchTypeValueOf(String name) {
  switch (name) {
    case 'DISCUSSION':
      return _$gSearchTypeDISCUSSION;
    case 'ISSUE':
      return _$gSearchTypeISSUE;
    case 'REPOSITORY':
      return _$gSearchTypeREPOSITORY;
    case 'USER':
      return _$gSearchTypeUSER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSearchType> _$gSearchTypeValues =
    new BuiltSet<GSearchType>(const <GSearchType>[
  _$gSearchTypeDISCUSSION,
  _$gSearchTypeISSUE,
  _$gSearchTypeREPOSITORY,
  _$gSearchTypeUSER,
]);

const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemCOMPOSER =
    const GSecurityAdvisoryEcosystem._('COMPOSER');
const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemGO =
    const GSecurityAdvisoryEcosystem._('GO');
const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemMAVEN =
    const GSecurityAdvisoryEcosystem._('MAVEN');
const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemNPM =
    const GSecurityAdvisoryEcosystem._('NPM');
const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemNUGET =
    const GSecurityAdvisoryEcosystem._('NUGET');
const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemPIP =
    const GSecurityAdvisoryEcosystem._('PIP');
const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemRUBYGEMS =
    const GSecurityAdvisoryEcosystem._('RUBYGEMS');

GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemValueOf(String name) {
  switch (name) {
    case 'COMPOSER':
      return _$gSecurityAdvisoryEcosystemCOMPOSER;
    case 'GO':
      return _$gSecurityAdvisoryEcosystemGO;
    case 'MAVEN':
      return _$gSecurityAdvisoryEcosystemMAVEN;
    case 'NPM':
      return _$gSecurityAdvisoryEcosystemNPM;
    case 'NUGET':
      return _$gSecurityAdvisoryEcosystemNUGET;
    case 'PIP':
      return _$gSecurityAdvisoryEcosystemPIP;
    case 'RUBYGEMS':
      return _$gSecurityAdvisoryEcosystemRUBYGEMS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSecurityAdvisoryEcosystem> _$gSecurityAdvisoryEcosystemValues =
    new BuiltSet<GSecurityAdvisoryEcosystem>(const <GSecurityAdvisoryEcosystem>[
  _$gSecurityAdvisoryEcosystemCOMPOSER,
  _$gSecurityAdvisoryEcosystemGO,
  _$gSecurityAdvisoryEcosystemMAVEN,
  _$gSecurityAdvisoryEcosystemNPM,
  _$gSecurityAdvisoryEcosystemNUGET,
  _$gSecurityAdvisoryEcosystemPIP,
  _$gSecurityAdvisoryEcosystemRUBYGEMS,
]);

const GSecurityAdvisoryIdentifierType _$gSecurityAdvisoryIdentifierTypeCVE =
    const GSecurityAdvisoryIdentifierType._('CVE');
const GSecurityAdvisoryIdentifierType _$gSecurityAdvisoryIdentifierTypeGHSA =
    const GSecurityAdvisoryIdentifierType._('GHSA');

GSecurityAdvisoryIdentifierType _$gSecurityAdvisoryIdentifierTypeValueOf(
    String name) {
  switch (name) {
    case 'CVE':
      return _$gSecurityAdvisoryIdentifierTypeCVE;
    case 'GHSA':
      return _$gSecurityAdvisoryIdentifierTypeGHSA;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSecurityAdvisoryIdentifierType>
    _$gSecurityAdvisoryIdentifierTypeValues =
    new BuiltSet<GSecurityAdvisoryIdentifierType>(const <
        GSecurityAdvisoryIdentifierType>[
  _$gSecurityAdvisoryIdentifierTypeCVE,
  _$gSecurityAdvisoryIdentifierTypeGHSA,
]);

const GSecurityAdvisoryOrderField _$gSecurityAdvisoryOrderFieldPUBLISHED_AT =
    const GSecurityAdvisoryOrderField._('PUBLISHED_AT');
const GSecurityAdvisoryOrderField _$gSecurityAdvisoryOrderFieldUPDATED_AT =
    const GSecurityAdvisoryOrderField._('UPDATED_AT');

GSecurityAdvisoryOrderField _$gSecurityAdvisoryOrderFieldValueOf(String name) {
  switch (name) {
    case 'PUBLISHED_AT':
      return _$gSecurityAdvisoryOrderFieldPUBLISHED_AT;
    case 'UPDATED_AT':
      return _$gSecurityAdvisoryOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSecurityAdvisoryOrderField>
    _$gSecurityAdvisoryOrderFieldValues = new BuiltSet<
        GSecurityAdvisoryOrderField>(const <GSecurityAdvisoryOrderField>[
  _$gSecurityAdvisoryOrderFieldPUBLISHED_AT,
  _$gSecurityAdvisoryOrderFieldUPDATED_AT,
]);

const GSecurityAdvisorySeverity _$gSecurityAdvisorySeverityCRITICAL =
    const GSecurityAdvisorySeverity._('CRITICAL');
const GSecurityAdvisorySeverity _$gSecurityAdvisorySeverityHIGH =
    const GSecurityAdvisorySeverity._('HIGH');
const GSecurityAdvisorySeverity _$gSecurityAdvisorySeverityLOW =
    const GSecurityAdvisorySeverity._('LOW');
const GSecurityAdvisorySeverity _$gSecurityAdvisorySeverityMODERATE =
    const GSecurityAdvisorySeverity._('MODERATE');

GSecurityAdvisorySeverity _$gSecurityAdvisorySeverityValueOf(String name) {
  switch (name) {
    case 'CRITICAL':
      return _$gSecurityAdvisorySeverityCRITICAL;
    case 'HIGH':
      return _$gSecurityAdvisorySeverityHIGH;
    case 'LOW':
      return _$gSecurityAdvisorySeverityLOW;
    case 'MODERATE':
      return _$gSecurityAdvisorySeverityMODERATE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSecurityAdvisorySeverity> _$gSecurityAdvisorySeverityValues =
    new BuiltSet<GSecurityAdvisorySeverity>(const <GSecurityAdvisorySeverity>[
  _$gSecurityAdvisorySeverityCRITICAL,
  _$gSecurityAdvisorySeverityHIGH,
  _$gSecurityAdvisorySeverityLOW,
  _$gSecurityAdvisorySeverityMODERATE,
]);

const GSecurityVulnerabilityOrderField
    _$gSecurityVulnerabilityOrderFieldUPDATED_AT =
    const GSecurityVulnerabilityOrderField._('UPDATED_AT');

GSecurityVulnerabilityOrderField _$gSecurityVulnerabilityOrderFieldValueOf(
    String name) {
  switch (name) {
    case 'UPDATED_AT':
      return _$gSecurityVulnerabilityOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSecurityVulnerabilityOrderField>
    _$gSecurityVulnerabilityOrderFieldValues =
    new BuiltSet<GSecurityVulnerabilityOrderField>(const <
        GSecurityVulnerabilityOrderField>[
  _$gSecurityVulnerabilityOrderFieldUPDATED_AT,
]);

const GSponsorableOrderField _$gSponsorableOrderFieldLOGIN =
    const GSponsorableOrderField._('LOGIN');

GSponsorableOrderField _$gSponsorableOrderFieldValueOf(String name) {
  switch (name) {
    case 'LOGIN':
      return _$gSponsorableOrderFieldLOGIN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSponsorableOrderField> _$gSponsorableOrderFieldValues =
    new BuiltSet<GSponsorableOrderField>(const <GSponsorableOrderField>[
  _$gSponsorableOrderFieldLOGIN,
]);

const GSponsorsGoalKind _$gSponsorsGoalKindMONTHLY_SPONSORSHIP_AMOUNT =
    const GSponsorsGoalKind._('MONTHLY_SPONSORSHIP_AMOUNT');
const GSponsorsGoalKind _$gSponsorsGoalKindTOTAL_SPONSORS_COUNT =
    const GSponsorsGoalKind._('TOTAL_SPONSORS_COUNT');

GSponsorsGoalKind _$gSponsorsGoalKindValueOf(String name) {
  switch (name) {
    case 'MONTHLY_SPONSORSHIP_AMOUNT':
      return _$gSponsorsGoalKindMONTHLY_SPONSORSHIP_AMOUNT;
    case 'TOTAL_SPONSORS_COUNT':
      return _$gSponsorsGoalKindTOTAL_SPONSORS_COUNT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSponsorsGoalKind> _$gSponsorsGoalKindValues =
    new BuiltSet<GSponsorsGoalKind>(const <GSponsorsGoalKind>[
  _$gSponsorsGoalKindMONTHLY_SPONSORSHIP_AMOUNT,
  _$gSponsorsGoalKindTOTAL_SPONSORS_COUNT,
]);

const GSponsorsTierOrderField _$gSponsorsTierOrderFieldCREATED_AT =
    const GSponsorsTierOrderField._('CREATED_AT');
const GSponsorsTierOrderField _$gSponsorsTierOrderFieldMONTHLY_PRICE_IN_CENTS =
    const GSponsorsTierOrderField._('MONTHLY_PRICE_IN_CENTS');

GSponsorsTierOrderField _$gSponsorsTierOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gSponsorsTierOrderFieldCREATED_AT;
    case 'MONTHLY_PRICE_IN_CENTS':
      return _$gSponsorsTierOrderFieldMONTHLY_PRICE_IN_CENTS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSponsorsTierOrderField> _$gSponsorsTierOrderFieldValues =
    new BuiltSet<GSponsorsTierOrderField>(const <GSponsorsTierOrderField>[
  _$gSponsorsTierOrderFieldCREATED_AT,
  _$gSponsorsTierOrderFieldMONTHLY_PRICE_IN_CENTS,
]);

const GSponsorshipOrderField _$gSponsorshipOrderFieldCREATED_AT =
    const GSponsorshipOrderField._('CREATED_AT');

GSponsorshipOrderField _$gSponsorshipOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gSponsorshipOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSponsorshipOrderField> _$gSponsorshipOrderFieldValues =
    new BuiltSet<GSponsorshipOrderField>(const <GSponsorshipOrderField>[
  _$gSponsorshipOrderFieldCREATED_AT,
]);

const GSponsorshipPrivacy _$gSponsorshipPrivacyPRIVATE =
    const GSponsorshipPrivacy._('PRIVATE');
const GSponsorshipPrivacy _$gSponsorshipPrivacyPUBLIC =
    const GSponsorshipPrivacy._('PUBLIC');

GSponsorshipPrivacy _$gSponsorshipPrivacyValueOf(String name) {
  switch (name) {
    case 'PRIVATE':
      return _$gSponsorshipPrivacyPRIVATE;
    case 'PUBLIC':
      return _$gSponsorshipPrivacyPUBLIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSponsorshipPrivacy> _$gSponsorshipPrivacyValues =
    new BuiltSet<GSponsorshipPrivacy>(const <GSponsorshipPrivacy>[
  _$gSponsorshipPrivacyPRIVATE,
  _$gSponsorshipPrivacyPUBLIC,
]);

const GStarOrderField _$gStarOrderFieldSTARRED_AT =
    const GStarOrderField._('STARRED_AT');

GStarOrderField _$gStarOrderFieldValueOf(String name) {
  switch (name) {
    case 'STARRED_AT':
      return _$gStarOrderFieldSTARRED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GStarOrderField> _$gStarOrderFieldValues =
    new BuiltSet<GStarOrderField>(const <GStarOrderField>[
  _$gStarOrderFieldSTARRED_AT,
]);

const GStatusState _$gStatusStateERROR = const GStatusState._('ERROR');
const GStatusState _$gStatusStateEXPECTED = const GStatusState._('EXPECTED');
const GStatusState _$gStatusStateFAILURE = const GStatusState._('FAILURE');
const GStatusState _$gStatusStatePENDING = const GStatusState._('PENDING');
const GStatusState _$gStatusStateSUCCESS = const GStatusState._('SUCCESS');

GStatusState _$gStatusStateValueOf(String name) {
  switch (name) {
    case 'ERROR':
      return _$gStatusStateERROR;
    case 'EXPECTED':
      return _$gStatusStateEXPECTED;
    case 'FAILURE':
      return _$gStatusStateFAILURE;
    case 'PENDING':
      return _$gStatusStatePENDING;
    case 'SUCCESS':
      return _$gStatusStateSUCCESS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GStatusState> _$gStatusStateValues =
    new BuiltSet<GStatusState>(const <GStatusState>[
  _$gStatusStateERROR,
  _$gStatusStateEXPECTED,
  _$gStatusStateFAILURE,
  _$gStatusStatePENDING,
  _$gStatusStateSUCCESS,
]);

const GSubscriptionState _$gSubscriptionStateIGNORED =
    const GSubscriptionState._('IGNORED');
const GSubscriptionState _$gSubscriptionStateSUBSCRIBED =
    const GSubscriptionState._('SUBSCRIBED');
const GSubscriptionState _$gSubscriptionStateUNSUBSCRIBED =
    const GSubscriptionState._('UNSUBSCRIBED');

GSubscriptionState _$gSubscriptionStateValueOf(String name) {
  switch (name) {
    case 'IGNORED':
      return _$gSubscriptionStateIGNORED;
    case 'SUBSCRIBED':
      return _$gSubscriptionStateSUBSCRIBED;
    case 'UNSUBSCRIBED':
      return _$gSubscriptionStateUNSUBSCRIBED;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GSubscriptionState> _$gSubscriptionStateValues =
    new BuiltSet<GSubscriptionState>(const <GSubscriptionState>[
  _$gSubscriptionStateIGNORED,
  _$gSubscriptionStateSUBSCRIBED,
  _$gSubscriptionStateUNSUBSCRIBED,
]);

const GTeamDiscussionCommentOrderField
    _$gTeamDiscussionCommentOrderFieldNUMBER =
    const GTeamDiscussionCommentOrderField._('NUMBER');

GTeamDiscussionCommentOrderField _$gTeamDiscussionCommentOrderFieldValueOf(
    String name) {
  switch (name) {
    case 'NUMBER':
      return _$gTeamDiscussionCommentOrderFieldNUMBER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamDiscussionCommentOrderField>
    _$gTeamDiscussionCommentOrderFieldValues =
    new BuiltSet<GTeamDiscussionCommentOrderField>(const <
        GTeamDiscussionCommentOrderField>[
  _$gTeamDiscussionCommentOrderFieldNUMBER,
]);

const GTeamDiscussionOrderField _$gTeamDiscussionOrderFieldCREATED_AT =
    const GTeamDiscussionOrderField._('CREATED_AT');

GTeamDiscussionOrderField _$gTeamDiscussionOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gTeamDiscussionOrderFieldCREATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamDiscussionOrderField> _$gTeamDiscussionOrderFieldValues =
    new BuiltSet<GTeamDiscussionOrderField>(const <GTeamDiscussionOrderField>[
  _$gTeamDiscussionOrderFieldCREATED_AT,
]);

const GTeamMemberOrderField _$gTeamMemberOrderFieldCREATED_AT =
    const GTeamMemberOrderField._('CREATED_AT');
const GTeamMemberOrderField _$gTeamMemberOrderFieldLOGIN =
    const GTeamMemberOrderField._('LOGIN');

GTeamMemberOrderField _$gTeamMemberOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gTeamMemberOrderFieldCREATED_AT;
    case 'LOGIN':
      return _$gTeamMemberOrderFieldLOGIN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamMemberOrderField> _$gTeamMemberOrderFieldValues =
    new BuiltSet<GTeamMemberOrderField>(const <GTeamMemberOrderField>[
  _$gTeamMemberOrderFieldCREATED_AT,
  _$gTeamMemberOrderFieldLOGIN,
]);

const GTeamMemberRole _$gTeamMemberRoleMAINTAINER =
    const GTeamMemberRole._('MAINTAINER');
const GTeamMemberRole _$gTeamMemberRoleMEMBER =
    const GTeamMemberRole._('MEMBER');

GTeamMemberRole _$gTeamMemberRoleValueOf(String name) {
  switch (name) {
    case 'MAINTAINER':
      return _$gTeamMemberRoleMAINTAINER;
    case 'MEMBER':
      return _$gTeamMemberRoleMEMBER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamMemberRole> _$gTeamMemberRoleValues =
    new BuiltSet<GTeamMemberRole>(const <GTeamMemberRole>[
  _$gTeamMemberRoleMAINTAINER,
  _$gTeamMemberRoleMEMBER,
]);

const GTeamMembershipType _$gTeamMembershipTypeALL =
    const GTeamMembershipType._('ALL');
const GTeamMembershipType _$gTeamMembershipTypeCHILD_TEAM =
    const GTeamMembershipType._('CHILD_TEAM');
const GTeamMembershipType _$gTeamMembershipTypeIMMEDIATE =
    const GTeamMembershipType._('IMMEDIATE');

GTeamMembershipType _$gTeamMembershipTypeValueOf(String name) {
  switch (name) {
    case 'ALL':
      return _$gTeamMembershipTypeALL;
    case 'CHILD_TEAM':
      return _$gTeamMembershipTypeCHILD_TEAM;
    case 'IMMEDIATE':
      return _$gTeamMembershipTypeIMMEDIATE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamMembershipType> _$gTeamMembershipTypeValues =
    new BuiltSet<GTeamMembershipType>(const <GTeamMembershipType>[
  _$gTeamMembershipTypeALL,
  _$gTeamMembershipTypeCHILD_TEAM,
  _$gTeamMembershipTypeIMMEDIATE,
]);

const GTeamOrderField _$gTeamOrderFieldNAME = const GTeamOrderField._('NAME');

GTeamOrderField _$gTeamOrderFieldValueOf(String name) {
  switch (name) {
    case 'NAME':
      return _$gTeamOrderFieldNAME;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamOrderField> _$gTeamOrderFieldValues =
    new BuiltSet<GTeamOrderField>(const <GTeamOrderField>[
  _$gTeamOrderFieldNAME,
]);

const GTeamPrivacy _$gTeamPrivacySECRET = const GTeamPrivacy._('SECRET');
const GTeamPrivacy _$gTeamPrivacyVISIBLE = const GTeamPrivacy._('VISIBLE');

GTeamPrivacy _$gTeamPrivacyValueOf(String name) {
  switch (name) {
    case 'SECRET':
      return _$gTeamPrivacySECRET;
    case 'VISIBLE':
      return _$gTeamPrivacyVISIBLE;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamPrivacy> _$gTeamPrivacyValues =
    new BuiltSet<GTeamPrivacy>(const <GTeamPrivacy>[
  _$gTeamPrivacySECRET,
  _$gTeamPrivacyVISIBLE,
]);

const GTeamRepositoryOrderField _$gTeamRepositoryOrderFieldCREATED_AT =
    const GTeamRepositoryOrderField._('CREATED_AT');
const GTeamRepositoryOrderField _$gTeamRepositoryOrderFieldNAME =
    const GTeamRepositoryOrderField._('NAME');
const GTeamRepositoryOrderField _$gTeamRepositoryOrderFieldPERMISSION =
    const GTeamRepositoryOrderField._('PERMISSION');
const GTeamRepositoryOrderField _$gTeamRepositoryOrderFieldPUSHED_AT =
    const GTeamRepositoryOrderField._('PUSHED_AT');
const GTeamRepositoryOrderField _$gTeamRepositoryOrderFieldSTARGAZERS =
    const GTeamRepositoryOrderField._('STARGAZERS');
const GTeamRepositoryOrderField _$gTeamRepositoryOrderFieldUPDATED_AT =
    const GTeamRepositoryOrderField._('UPDATED_AT');

GTeamRepositoryOrderField _$gTeamRepositoryOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gTeamRepositoryOrderFieldCREATED_AT;
    case 'NAME':
      return _$gTeamRepositoryOrderFieldNAME;
    case 'PERMISSION':
      return _$gTeamRepositoryOrderFieldPERMISSION;
    case 'PUSHED_AT':
      return _$gTeamRepositoryOrderFieldPUSHED_AT;
    case 'STARGAZERS':
      return _$gTeamRepositoryOrderFieldSTARGAZERS;
    case 'UPDATED_AT':
      return _$gTeamRepositoryOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamRepositoryOrderField> _$gTeamRepositoryOrderFieldValues =
    new BuiltSet<GTeamRepositoryOrderField>(const <GTeamRepositoryOrderField>[
  _$gTeamRepositoryOrderFieldCREATED_AT,
  _$gTeamRepositoryOrderFieldNAME,
  _$gTeamRepositoryOrderFieldPERMISSION,
  _$gTeamRepositoryOrderFieldPUSHED_AT,
  _$gTeamRepositoryOrderFieldSTARGAZERS,
  _$gTeamRepositoryOrderFieldUPDATED_AT,
]);

const GTeamRole _$gTeamRoleADMIN = const GTeamRole._('ADMIN');
const GTeamRole _$gTeamRoleMEMBER = const GTeamRole._('MEMBER');

GTeamRole _$gTeamRoleValueOf(String name) {
  switch (name) {
    case 'ADMIN':
      return _$gTeamRoleADMIN;
    case 'MEMBER':
      return _$gTeamRoleMEMBER;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTeamRole> _$gTeamRoleValues =
    new BuiltSet<GTeamRole>(const <GTeamRole>[
  _$gTeamRoleADMIN,
  _$gTeamRoleMEMBER,
]);

const GTopicSuggestionDeclineReason
    _$gTopicSuggestionDeclineReasonNOT_RELEVANT =
    const GTopicSuggestionDeclineReason._('NOT_RELEVANT');
const GTopicSuggestionDeclineReason
    _$gTopicSuggestionDeclineReasonPERSONAL_PREFERENCE =
    const GTopicSuggestionDeclineReason._('PERSONAL_PREFERENCE');
const GTopicSuggestionDeclineReason _$gTopicSuggestionDeclineReasonTOO_GENERAL =
    const GTopicSuggestionDeclineReason._('TOO_GENERAL');
const GTopicSuggestionDeclineReason
    _$gTopicSuggestionDeclineReasonTOO_SPECIFIC =
    const GTopicSuggestionDeclineReason._('TOO_SPECIFIC');

GTopicSuggestionDeclineReason _$gTopicSuggestionDeclineReasonValueOf(
    String name) {
  switch (name) {
    case 'NOT_RELEVANT':
      return _$gTopicSuggestionDeclineReasonNOT_RELEVANT;
    case 'PERSONAL_PREFERENCE':
      return _$gTopicSuggestionDeclineReasonPERSONAL_PREFERENCE;
    case 'TOO_GENERAL':
      return _$gTopicSuggestionDeclineReasonTOO_GENERAL;
    case 'TOO_SPECIFIC':
      return _$gTopicSuggestionDeclineReasonTOO_SPECIFIC;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GTopicSuggestionDeclineReason>
    _$gTopicSuggestionDeclineReasonValues = new BuiltSet<
        GTopicSuggestionDeclineReason>(const <GTopicSuggestionDeclineReason>[
  _$gTopicSuggestionDeclineReasonNOT_RELEVANT,
  _$gTopicSuggestionDeclineReasonPERSONAL_PREFERENCE,
  _$gTopicSuggestionDeclineReasonTOO_GENERAL,
  _$gTopicSuggestionDeclineReasonTOO_SPECIFIC,
]);

const GUserBlockDuration _$gUserBlockDurationONE_DAY =
    const GUserBlockDuration._('ONE_DAY');
const GUserBlockDuration _$gUserBlockDurationONE_MONTH =
    const GUserBlockDuration._('ONE_MONTH');
const GUserBlockDuration _$gUserBlockDurationONE_WEEK =
    const GUserBlockDuration._('ONE_WEEK');
const GUserBlockDuration _$gUserBlockDurationPERMANENT =
    const GUserBlockDuration._('PERMANENT');
const GUserBlockDuration _$gUserBlockDurationTHREE_DAYS =
    const GUserBlockDuration._('THREE_DAYS');

GUserBlockDuration _$gUserBlockDurationValueOf(String name) {
  switch (name) {
    case 'ONE_DAY':
      return _$gUserBlockDurationONE_DAY;
    case 'ONE_MONTH':
      return _$gUserBlockDurationONE_MONTH;
    case 'ONE_WEEK':
      return _$gUserBlockDurationONE_WEEK;
    case 'PERMANENT':
      return _$gUserBlockDurationPERMANENT;
    case 'THREE_DAYS':
      return _$gUserBlockDurationTHREE_DAYS;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GUserBlockDuration> _$gUserBlockDurationValues =
    new BuiltSet<GUserBlockDuration>(const <GUserBlockDuration>[
  _$gUserBlockDurationONE_DAY,
  _$gUserBlockDurationONE_MONTH,
  _$gUserBlockDurationONE_WEEK,
  _$gUserBlockDurationPERMANENT,
  _$gUserBlockDurationTHREE_DAYS,
]);

const GUserStatusOrderField _$gUserStatusOrderFieldUPDATED_AT =
    const GUserStatusOrderField._('UPDATED_AT');

GUserStatusOrderField _$gUserStatusOrderFieldValueOf(String name) {
  switch (name) {
    case 'UPDATED_AT':
      return _$gUserStatusOrderFieldUPDATED_AT;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GUserStatusOrderField> _$gUserStatusOrderFieldValues =
    new BuiltSet<GUserStatusOrderField>(const <GUserStatusOrderField>[
  _$gUserStatusOrderFieldUPDATED_AT,
]);

const GVerifiableDomainOrderField _$gVerifiableDomainOrderFieldCREATED_AT =
    const GVerifiableDomainOrderField._('CREATED_AT');
const GVerifiableDomainOrderField _$gVerifiableDomainOrderFieldDOMAIN =
    const GVerifiableDomainOrderField._('DOMAIN');

GVerifiableDomainOrderField _$gVerifiableDomainOrderFieldValueOf(String name) {
  switch (name) {
    case 'CREATED_AT':
      return _$gVerifiableDomainOrderFieldCREATED_AT;
    case 'DOMAIN':
      return _$gVerifiableDomainOrderFieldDOMAIN;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GVerifiableDomainOrderField>
    _$gVerifiableDomainOrderFieldValues = new BuiltSet<
        GVerifiableDomainOrderField>(const <GVerifiableDomainOrderField>[
  _$gVerifiableDomainOrderFieldCREATED_AT,
  _$gVerifiableDomainOrderFieldDOMAIN,
]);

Serializer<GAcceptEnterpriseAdministratorInvitationInput>
    _$gAcceptEnterpriseAdministratorInvitationInputSerializer =
    new _$GAcceptEnterpriseAdministratorInvitationInputSerializer();
Serializer<GAcceptTopicSuggestionInput>
    _$gAcceptTopicSuggestionInputSerializer =
    new _$GAcceptTopicSuggestionInputSerializer();
Serializer<GAddAssigneesToAssignableInput>
    _$gAddAssigneesToAssignableInputSerializer =
    new _$GAddAssigneesToAssignableInputSerializer();
Serializer<GAddCommentInput> _$gAddCommentInputSerializer =
    new _$GAddCommentInputSerializer();
Serializer<GAddDiscussionCommentInput> _$gAddDiscussionCommentInputSerializer =
    new _$GAddDiscussionCommentInputSerializer();
Serializer<GAddEnterpriseSupportEntitlementInput>
    _$gAddEnterpriseSupportEntitlementInputSerializer =
    new _$GAddEnterpriseSupportEntitlementInputSerializer();
Serializer<GAddLabelsToLabelableInput> _$gAddLabelsToLabelableInputSerializer =
    new _$GAddLabelsToLabelableInputSerializer();
Serializer<GAddProjectCardInput> _$gAddProjectCardInputSerializer =
    new _$GAddProjectCardInputSerializer();
Serializer<GAddProjectColumnInput> _$gAddProjectColumnInputSerializer =
    new _$GAddProjectColumnInputSerializer();
Serializer<GAddPullRequestReviewCommentInput>
    _$gAddPullRequestReviewCommentInputSerializer =
    new _$GAddPullRequestReviewCommentInputSerializer();
Serializer<GAddPullRequestReviewInput> _$gAddPullRequestReviewInputSerializer =
    new _$GAddPullRequestReviewInputSerializer();
Serializer<GAddPullRequestReviewThreadInput>
    _$gAddPullRequestReviewThreadInputSerializer =
    new _$GAddPullRequestReviewThreadInputSerializer();
Serializer<GAddReactionInput> _$gAddReactionInputSerializer =
    new _$GAddReactionInputSerializer();
Serializer<GAddStarInput> _$gAddStarInputSerializer =
    new _$GAddStarInputSerializer();
Serializer<GAddUpvoteInput> _$gAddUpvoteInputSerializer =
    new _$GAddUpvoteInputSerializer();
Serializer<GAddVerifiableDomainInput> _$gAddVerifiableDomainInputSerializer =
    new _$GAddVerifiableDomainInputSerializer();
Serializer<GApproveDeploymentsInput> _$gApproveDeploymentsInputSerializer =
    new _$GApproveDeploymentsInputSerializer();
Serializer<GApproveVerifiableDomainInput>
    _$gApproveVerifiableDomainInputSerializer =
    new _$GApproveVerifiableDomainInputSerializer();
Serializer<GArchiveRepositoryInput> _$gArchiveRepositoryInputSerializer =
    new _$GArchiveRepositoryInputSerializer();
Serializer<GAuditLogOrder> _$gAuditLogOrderSerializer =
    new _$GAuditLogOrderSerializer();
Serializer<GAuditLogOrderField> _$gAuditLogOrderFieldSerializer =
    new _$GAuditLogOrderFieldSerializer();
Serializer<GCancelEnterpriseAdminInvitationInput>
    _$gCancelEnterpriseAdminInvitationInputSerializer =
    new _$GCancelEnterpriseAdminInvitationInputSerializer();
Serializer<GChangeUserStatusInput> _$gChangeUserStatusInputSerializer =
    new _$GChangeUserStatusInputSerializer();
Serializer<GCheckAnnotationData> _$gCheckAnnotationDataSerializer =
    new _$GCheckAnnotationDataSerializer();
Serializer<GCheckAnnotationLevel> _$gCheckAnnotationLevelSerializer =
    new _$GCheckAnnotationLevelSerializer();
Serializer<GCheckAnnotationRange> _$gCheckAnnotationRangeSerializer =
    new _$GCheckAnnotationRangeSerializer();
Serializer<GCheckConclusionState> _$gCheckConclusionStateSerializer =
    new _$GCheckConclusionStateSerializer();
Serializer<GCheckRunAction> _$gCheckRunActionSerializer =
    new _$GCheckRunActionSerializer();
Serializer<GCheckRunFilter> _$gCheckRunFilterSerializer =
    new _$GCheckRunFilterSerializer();
Serializer<GCheckRunOutput> _$gCheckRunOutputSerializer =
    new _$GCheckRunOutputSerializer();
Serializer<GCheckRunOutputImage> _$gCheckRunOutputImageSerializer =
    new _$GCheckRunOutputImageSerializer();
Serializer<GCheckRunType> _$gCheckRunTypeSerializer =
    new _$GCheckRunTypeSerializer();
Serializer<GCheckStatusState> _$gCheckStatusStateSerializer =
    new _$GCheckStatusStateSerializer();
Serializer<GCheckSuiteAutoTriggerPreference>
    _$gCheckSuiteAutoTriggerPreferenceSerializer =
    new _$GCheckSuiteAutoTriggerPreferenceSerializer();
Serializer<GCheckSuiteFilter> _$gCheckSuiteFilterSerializer =
    new _$GCheckSuiteFilterSerializer();
Serializer<GClearLabelsFromLabelableInput>
    _$gClearLabelsFromLabelableInputSerializer =
    new _$GClearLabelsFromLabelableInputSerializer();
Serializer<GCloneProjectInput> _$gCloneProjectInputSerializer =
    new _$GCloneProjectInputSerializer();
Serializer<GCloneTemplateRepositoryInput>
    _$gCloneTemplateRepositoryInputSerializer =
    new _$GCloneTemplateRepositoryInputSerializer();
Serializer<GCloseIssueInput> _$gCloseIssueInputSerializer =
    new _$GCloseIssueInputSerializer();
Serializer<GClosePullRequestInput> _$gClosePullRequestInputSerializer =
    new _$GClosePullRequestInputSerializer();
Serializer<GCollaboratorAffiliation> _$gCollaboratorAffiliationSerializer =
    new _$GCollaboratorAffiliationSerializer();
Serializer<GCommentAuthorAssociation> _$gCommentAuthorAssociationSerializer =
    new _$GCommentAuthorAssociationSerializer();
Serializer<GCommentCannotUpdateReason> _$gCommentCannotUpdateReasonSerializer =
    new _$GCommentCannotUpdateReasonSerializer();
Serializer<GCommitAuthor> _$gCommitAuthorSerializer =
    new _$GCommitAuthorSerializer();
Serializer<GCommitContributionOrder> _$gCommitContributionOrderSerializer =
    new _$GCommitContributionOrderSerializer();
Serializer<GCommitContributionOrderField>
    _$gCommitContributionOrderFieldSerializer =
    new _$GCommitContributionOrderFieldSerializer();
Serializer<GContributionLevel> _$gContributionLevelSerializer =
    new _$GContributionLevelSerializer();
Serializer<GContributionOrder> _$gContributionOrderSerializer =
    new _$GContributionOrderSerializer();
Serializer<GConvertProjectCardNoteToIssueInput>
    _$gConvertProjectCardNoteToIssueInputSerializer =
    new _$GConvertProjectCardNoteToIssueInputSerializer();
Serializer<GConvertPullRequestToDraftInput>
    _$gConvertPullRequestToDraftInputSerializer =
    new _$GConvertPullRequestToDraftInputSerializer();
Serializer<GCreateBranchProtectionRuleInput>
    _$gCreateBranchProtectionRuleInputSerializer =
    new _$GCreateBranchProtectionRuleInputSerializer();
Serializer<GCreateCheckRunInput> _$gCreateCheckRunInputSerializer =
    new _$GCreateCheckRunInputSerializer();
Serializer<GCreateCheckSuiteInput> _$gCreateCheckSuiteInputSerializer =
    new _$GCreateCheckSuiteInputSerializer();
Serializer<GCreateDiscussionInput> _$gCreateDiscussionInputSerializer =
    new _$GCreateDiscussionInputSerializer();
Serializer<GCreateEnterpriseOrganizationInput>
    _$gCreateEnterpriseOrganizationInputSerializer =
    new _$GCreateEnterpriseOrganizationInputSerializer();
Serializer<GCreateEnvironmentInput> _$gCreateEnvironmentInputSerializer =
    new _$GCreateEnvironmentInputSerializer();
Serializer<GCreateIpAllowListEntryInput>
    _$gCreateIpAllowListEntryInputSerializer =
    new _$GCreateIpAllowListEntryInputSerializer();
Serializer<GCreateIssueInput> _$gCreateIssueInputSerializer =
    new _$GCreateIssueInputSerializer();
Serializer<GCreateProjectInput> _$gCreateProjectInputSerializer =
    new _$GCreateProjectInputSerializer();
Serializer<GCreatePullRequestInput> _$gCreatePullRequestInputSerializer =
    new _$GCreatePullRequestInputSerializer();
Serializer<GCreateRefInput> _$gCreateRefInputSerializer =
    new _$GCreateRefInputSerializer();
Serializer<GCreateRepositoryInput> _$gCreateRepositoryInputSerializer =
    new _$GCreateRepositoryInputSerializer();
Serializer<GCreateTeamDiscussionCommentInput>
    _$gCreateTeamDiscussionCommentInputSerializer =
    new _$GCreateTeamDiscussionCommentInputSerializer();
Serializer<GCreateTeamDiscussionInput> _$gCreateTeamDiscussionInputSerializer =
    new _$GCreateTeamDiscussionInputSerializer();
Serializer<GDeclineTopicSuggestionInput>
    _$gDeclineTopicSuggestionInputSerializer =
    new _$GDeclineTopicSuggestionInputSerializer();
Serializer<GDefaultRepositoryPermissionField>
    _$gDefaultRepositoryPermissionFieldSerializer =
    new _$GDefaultRepositoryPermissionFieldSerializer();
Serializer<GDeleteBranchProtectionRuleInput>
    _$gDeleteBranchProtectionRuleInputSerializer =
    new _$GDeleteBranchProtectionRuleInputSerializer();
Serializer<GDeleteDeploymentInput> _$gDeleteDeploymentInputSerializer =
    new _$GDeleteDeploymentInputSerializer();
Serializer<GDeleteDiscussionCommentInput>
    _$gDeleteDiscussionCommentInputSerializer =
    new _$GDeleteDiscussionCommentInputSerializer();
Serializer<GDeleteDiscussionInput> _$gDeleteDiscussionInputSerializer =
    new _$GDeleteDiscussionInputSerializer();
Serializer<GDeleteEnvironmentInput> _$gDeleteEnvironmentInputSerializer =
    new _$GDeleteEnvironmentInputSerializer();
Serializer<GDeleteIpAllowListEntryInput>
    _$gDeleteIpAllowListEntryInputSerializer =
    new _$GDeleteIpAllowListEntryInputSerializer();
Serializer<GDeleteIssueCommentInput> _$gDeleteIssueCommentInputSerializer =
    new _$GDeleteIssueCommentInputSerializer();
Serializer<GDeleteIssueInput> _$gDeleteIssueInputSerializer =
    new _$GDeleteIssueInputSerializer();
Serializer<GDeleteProjectCardInput> _$gDeleteProjectCardInputSerializer =
    new _$GDeleteProjectCardInputSerializer();
Serializer<GDeleteProjectColumnInput> _$gDeleteProjectColumnInputSerializer =
    new _$GDeleteProjectColumnInputSerializer();
Serializer<GDeleteProjectInput> _$gDeleteProjectInputSerializer =
    new _$GDeleteProjectInputSerializer();
Serializer<GDeletePullRequestReviewCommentInput>
    _$gDeletePullRequestReviewCommentInputSerializer =
    new _$GDeletePullRequestReviewCommentInputSerializer();
Serializer<GDeletePullRequestReviewInput>
    _$gDeletePullRequestReviewInputSerializer =
    new _$GDeletePullRequestReviewInputSerializer();
Serializer<GDeleteRefInput> _$gDeleteRefInputSerializer =
    new _$GDeleteRefInputSerializer();
Serializer<GDeleteTeamDiscussionCommentInput>
    _$gDeleteTeamDiscussionCommentInputSerializer =
    new _$GDeleteTeamDiscussionCommentInputSerializer();
Serializer<GDeleteTeamDiscussionInput> _$gDeleteTeamDiscussionInputSerializer =
    new _$GDeleteTeamDiscussionInputSerializer();
Serializer<GDeleteVerifiableDomainInput>
    _$gDeleteVerifiableDomainInputSerializer =
    new _$GDeleteVerifiableDomainInputSerializer();
Serializer<GDeploymentOrder> _$gDeploymentOrderSerializer =
    new _$GDeploymentOrderSerializer();
Serializer<GDeploymentOrderField> _$gDeploymentOrderFieldSerializer =
    new _$GDeploymentOrderFieldSerializer();
Serializer<GDeploymentProtectionRuleType>
    _$gDeploymentProtectionRuleTypeSerializer =
    new _$GDeploymentProtectionRuleTypeSerializer();
Serializer<GDeploymentReviewState> _$gDeploymentReviewStateSerializer =
    new _$GDeploymentReviewStateSerializer();
Serializer<GDeploymentState> _$gDeploymentStateSerializer =
    new _$GDeploymentStateSerializer();
Serializer<GDeploymentStatusState> _$gDeploymentStatusStateSerializer =
    new _$GDeploymentStatusStateSerializer();
Serializer<GDiffSide> _$gDiffSideSerializer = new _$GDiffSideSerializer();
Serializer<GDisablePullRequestAutoMergeInput>
    _$gDisablePullRequestAutoMergeInputSerializer =
    new _$GDisablePullRequestAutoMergeInputSerializer();
Serializer<GDiscussionOrder> _$gDiscussionOrderSerializer =
    new _$GDiscussionOrderSerializer();
Serializer<GDiscussionOrderField> _$gDiscussionOrderFieldSerializer =
    new _$GDiscussionOrderFieldSerializer();
Serializer<GDismissPullRequestReviewInput>
    _$gDismissPullRequestReviewInputSerializer =
    new _$GDismissPullRequestReviewInputSerializer();
Serializer<GDraftPullRequestReviewComment>
    _$gDraftPullRequestReviewCommentSerializer =
    new _$GDraftPullRequestReviewCommentSerializer();
Serializer<GDraftPullRequestReviewThread>
    _$gDraftPullRequestReviewThreadSerializer =
    new _$GDraftPullRequestReviewThreadSerializer();
Serializer<GEnablePullRequestAutoMergeInput>
    _$gEnablePullRequestAutoMergeInputSerializer =
    new _$GEnablePullRequestAutoMergeInputSerializer();
Serializer<GEnterpriseAdministratorInvitationOrder>
    _$gEnterpriseAdministratorInvitationOrderSerializer =
    new _$GEnterpriseAdministratorInvitationOrderSerializer();
Serializer<GEnterpriseAdministratorInvitationOrderField>
    _$gEnterpriseAdministratorInvitationOrderFieldSerializer =
    new _$GEnterpriseAdministratorInvitationOrderFieldSerializer();
Serializer<GEnterpriseAdministratorRole>
    _$gEnterpriseAdministratorRoleSerializer =
    new _$GEnterpriseAdministratorRoleSerializer();
Serializer<GEnterpriseDefaultRepositoryPermissionSettingValue>
    _$gEnterpriseDefaultRepositoryPermissionSettingValueSerializer =
    new _$GEnterpriseDefaultRepositoryPermissionSettingValueSerializer();
Serializer<GEnterpriseEnabledDisabledSettingValue>
    _$gEnterpriseEnabledDisabledSettingValueSerializer =
    new _$GEnterpriseEnabledDisabledSettingValueSerializer();
Serializer<GEnterpriseEnabledSettingValue>
    _$gEnterpriseEnabledSettingValueSerializer =
    new _$GEnterpriseEnabledSettingValueSerializer();
Serializer<GEnterpriseMemberOrder> _$gEnterpriseMemberOrderSerializer =
    new _$GEnterpriseMemberOrderSerializer();
Serializer<GEnterpriseMemberOrderField>
    _$gEnterpriseMemberOrderFieldSerializer =
    new _$GEnterpriseMemberOrderFieldSerializer();
Serializer<GEnterpriseMembersCanCreateRepositoriesSettingValue>
    _$gEnterpriseMembersCanCreateRepositoriesSettingValueSerializer =
    new _$GEnterpriseMembersCanCreateRepositoriesSettingValueSerializer();
Serializer<GEnterpriseMembersCanMakePurchasesSettingValue>
    _$gEnterpriseMembersCanMakePurchasesSettingValueSerializer =
    new _$GEnterpriseMembersCanMakePurchasesSettingValueSerializer();
Serializer<GEnterpriseServerInstallationOrder>
    _$gEnterpriseServerInstallationOrderSerializer =
    new _$GEnterpriseServerInstallationOrderSerializer();
Serializer<GEnterpriseServerInstallationOrderField>
    _$gEnterpriseServerInstallationOrderFieldSerializer =
    new _$GEnterpriseServerInstallationOrderFieldSerializer();
Serializer<GEnterpriseServerUserAccountEmailOrder>
    _$gEnterpriseServerUserAccountEmailOrderSerializer =
    new _$GEnterpriseServerUserAccountEmailOrderSerializer();
Serializer<GEnterpriseServerUserAccountEmailOrderField>
    _$gEnterpriseServerUserAccountEmailOrderFieldSerializer =
    new _$GEnterpriseServerUserAccountEmailOrderFieldSerializer();
Serializer<GEnterpriseServerUserAccountOrder>
    _$gEnterpriseServerUserAccountOrderSerializer =
    new _$GEnterpriseServerUserAccountOrderSerializer();
Serializer<GEnterpriseServerUserAccountOrderField>
    _$gEnterpriseServerUserAccountOrderFieldSerializer =
    new _$GEnterpriseServerUserAccountOrderFieldSerializer();
Serializer<GEnterpriseServerUserAccountsUploadOrder>
    _$gEnterpriseServerUserAccountsUploadOrderSerializer =
    new _$GEnterpriseServerUserAccountsUploadOrderSerializer();
Serializer<GEnterpriseServerUserAccountsUploadOrderField>
    _$gEnterpriseServerUserAccountsUploadOrderFieldSerializer =
    new _$GEnterpriseServerUserAccountsUploadOrderFieldSerializer();
Serializer<GEnterpriseServerUserAccountsUploadSyncState>
    _$gEnterpriseServerUserAccountsUploadSyncStateSerializer =
    new _$GEnterpriseServerUserAccountsUploadSyncStateSerializer();
Serializer<GEnterpriseUserAccountMembershipRole>
    _$gEnterpriseUserAccountMembershipRoleSerializer =
    new _$GEnterpriseUserAccountMembershipRoleSerializer();
Serializer<GEnterpriseUserDeployment> _$gEnterpriseUserDeploymentSerializer =
    new _$GEnterpriseUserDeploymentSerializer();
Serializer<GFileViewedState> _$gFileViewedStateSerializer =
    new _$GFileViewedStateSerializer();
Serializer<GFollowUserInput> _$gFollowUserInputSerializer =
    new _$GFollowUserInputSerializer();
Serializer<GFundingPlatform> _$gFundingPlatformSerializer =
    new _$GFundingPlatformSerializer();
Serializer<GGistOrder> _$gGistOrderSerializer = new _$GGistOrderSerializer();
Serializer<GGistOrderField> _$gGistOrderFieldSerializer =
    new _$GGistOrderFieldSerializer();
Serializer<GGistPrivacy> _$gGistPrivacySerializer =
    new _$GGistPrivacySerializer();
Serializer<GGitSignatureState> _$gGitSignatureStateSerializer =
    new _$GGitSignatureStateSerializer();
Serializer<GIdentityProviderConfigurationState>
    _$gIdentityProviderConfigurationStateSerializer =
    new _$GIdentityProviderConfigurationStateSerializer();
Serializer<GInviteEnterpriseAdminInput>
    _$gInviteEnterpriseAdminInputSerializer =
    new _$GInviteEnterpriseAdminInputSerializer();
Serializer<GIpAllowListEnabledSettingValue>
    _$gIpAllowListEnabledSettingValueSerializer =
    new _$GIpAllowListEnabledSettingValueSerializer();
Serializer<GIpAllowListEntryOrder> _$gIpAllowListEntryOrderSerializer =
    new _$GIpAllowListEntryOrderSerializer();
Serializer<GIpAllowListEntryOrderField>
    _$gIpAllowListEntryOrderFieldSerializer =
    new _$GIpAllowListEntryOrderFieldSerializer();
Serializer<GIssueCommentOrder> _$gIssueCommentOrderSerializer =
    new _$GIssueCommentOrderSerializer();
Serializer<GIssueCommentOrderField> _$gIssueCommentOrderFieldSerializer =
    new _$GIssueCommentOrderFieldSerializer();
Serializer<GIssueFilters> _$gIssueFiltersSerializer =
    new _$GIssueFiltersSerializer();
Serializer<GIssueOrder> _$gIssueOrderSerializer = new _$GIssueOrderSerializer();
Serializer<GIssueOrderField> _$gIssueOrderFieldSerializer =
    new _$GIssueOrderFieldSerializer();
Serializer<GIssueState> _$gIssueStateSerializer = new _$GIssueStateSerializer();
Serializer<GIssueTimelineItemsItemType>
    _$gIssueTimelineItemsItemTypeSerializer =
    new _$GIssueTimelineItemsItemTypeSerializer();
Serializer<GLabelOrder> _$gLabelOrderSerializer = new _$GLabelOrderSerializer();
Serializer<GLabelOrderField> _$gLabelOrderFieldSerializer =
    new _$GLabelOrderFieldSerializer();
Serializer<GLanguageOrder> _$gLanguageOrderSerializer =
    new _$GLanguageOrderSerializer();
Serializer<GLanguageOrderField> _$gLanguageOrderFieldSerializer =
    new _$GLanguageOrderFieldSerializer();
Serializer<GLinkRepositoryToProjectInput>
    _$gLinkRepositoryToProjectInputSerializer =
    new _$GLinkRepositoryToProjectInputSerializer();
Serializer<GLockLockableInput> _$gLockLockableInputSerializer =
    new _$GLockLockableInputSerializer();
Serializer<GLockReason> _$gLockReasonSerializer = new _$GLockReasonSerializer();
Serializer<GMarkDiscussionCommentAsAnswerInput>
    _$gMarkDiscussionCommentAsAnswerInputSerializer =
    new _$GMarkDiscussionCommentAsAnswerInputSerializer();
Serializer<GMarkFileAsViewedInput> _$gMarkFileAsViewedInputSerializer =
    new _$GMarkFileAsViewedInputSerializer();
Serializer<GMarkPullRequestReadyForReviewInput>
    _$gMarkPullRequestReadyForReviewInputSerializer =
    new _$GMarkPullRequestReadyForReviewInputSerializer();
Serializer<GMergeBranchInput> _$gMergeBranchInputSerializer =
    new _$GMergeBranchInputSerializer();
Serializer<GMergePullRequestInput> _$gMergePullRequestInputSerializer =
    new _$GMergePullRequestInputSerializer();
Serializer<GMergeableState> _$gMergeableStateSerializer =
    new _$GMergeableStateSerializer();
Serializer<GMilestoneOrder> _$gMilestoneOrderSerializer =
    new _$GMilestoneOrderSerializer();
Serializer<GMilestoneOrderField> _$gMilestoneOrderFieldSerializer =
    new _$GMilestoneOrderFieldSerializer();
Serializer<GMilestoneState> _$gMilestoneStateSerializer =
    new _$GMilestoneStateSerializer();
Serializer<GMinimizeCommentInput> _$gMinimizeCommentInputSerializer =
    new _$GMinimizeCommentInputSerializer();
Serializer<GMoveProjectCardInput> _$gMoveProjectCardInputSerializer =
    new _$GMoveProjectCardInputSerializer();
Serializer<GMoveProjectColumnInput> _$gMoveProjectColumnInputSerializer =
    new _$GMoveProjectColumnInputSerializer();
Serializer<GNotificationRestrictionSettingValue>
    _$gNotificationRestrictionSettingValueSerializer =
    new _$GNotificationRestrictionSettingValueSerializer();
Serializer<GOauthApplicationCreateAuditEntryState>
    _$gOauthApplicationCreateAuditEntryStateSerializer =
    new _$GOauthApplicationCreateAuditEntryStateSerializer();
Serializer<GOperationType> _$gOperationTypeSerializer =
    new _$GOperationTypeSerializer();
Serializer<GOrderDirection> _$gOrderDirectionSerializer =
    new _$GOrderDirectionSerializer();
Serializer<GOrgAddMemberAuditEntryPermission>
    _$gOrgAddMemberAuditEntryPermissionSerializer =
    new _$GOrgAddMemberAuditEntryPermissionSerializer();
Serializer<GOrgCreateAuditEntryBillingPlan>
    _$gOrgCreateAuditEntryBillingPlanSerializer =
    new _$GOrgCreateAuditEntryBillingPlanSerializer();
Serializer<GOrgRemoveBillingManagerAuditEntryReason>
    _$gOrgRemoveBillingManagerAuditEntryReasonSerializer =
    new _$GOrgRemoveBillingManagerAuditEntryReasonSerializer();
Serializer<GOrgRemoveMemberAuditEntryMembershipType>
    _$gOrgRemoveMemberAuditEntryMembershipTypeSerializer =
    new _$GOrgRemoveMemberAuditEntryMembershipTypeSerializer();
Serializer<GOrgRemoveMemberAuditEntryReason>
    _$gOrgRemoveMemberAuditEntryReasonSerializer =
    new _$GOrgRemoveMemberAuditEntryReasonSerializer();
Serializer<GOrgRemoveOutsideCollaboratorAuditEntryMembershipType>
    _$gOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeSerializer =
    new _$GOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeSerializer();
Serializer<GOrgRemoveOutsideCollaboratorAuditEntryReason>
    _$gOrgRemoveOutsideCollaboratorAuditEntryReasonSerializer =
    new _$GOrgRemoveOutsideCollaboratorAuditEntryReasonSerializer();
Serializer<GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission>
    _$gOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionSerializer =
    new _$GOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionSerializer();
Serializer<GOrgUpdateMemberAuditEntryPermission>
    _$gOrgUpdateMemberAuditEntryPermissionSerializer =
    new _$GOrgUpdateMemberAuditEntryPermissionSerializer();
Serializer<GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility>
    _$gOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilitySerializer =
    new _$GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilitySerializer();
Serializer<GOrganizationInvitationRole>
    _$gOrganizationInvitationRoleSerializer =
    new _$GOrganizationInvitationRoleSerializer();
Serializer<GOrganizationInvitationType>
    _$gOrganizationInvitationTypeSerializer =
    new _$GOrganizationInvitationTypeSerializer();
Serializer<GOrganizationMemberRole> _$gOrganizationMemberRoleSerializer =
    new _$GOrganizationMemberRoleSerializer();
Serializer<GOrganizationMembersCanCreateRepositoriesSettingValue>
    _$gOrganizationMembersCanCreateRepositoriesSettingValueSerializer =
    new _$GOrganizationMembersCanCreateRepositoriesSettingValueSerializer();
Serializer<GOrganizationOrder> _$gOrganizationOrderSerializer =
    new _$GOrganizationOrderSerializer();
Serializer<GOrganizationOrderField> _$gOrganizationOrderFieldSerializer =
    new _$GOrganizationOrderFieldSerializer();
Serializer<GPackageFileOrder> _$gPackageFileOrderSerializer =
    new _$GPackageFileOrderSerializer();
Serializer<GPackageFileOrderField> _$gPackageFileOrderFieldSerializer =
    new _$GPackageFileOrderFieldSerializer();
Serializer<GPackageOrder> _$gPackageOrderSerializer =
    new _$GPackageOrderSerializer();
Serializer<GPackageOrderField> _$gPackageOrderFieldSerializer =
    new _$GPackageOrderFieldSerializer();
Serializer<GPackageType> _$gPackageTypeSerializer =
    new _$GPackageTypeSerializer();
Serializer<GPackageVersionOrder> _$gPackageVersionOrderSerializer =
    new _$GPackageVersionOrderSerializer();
Serializer<GPackageVersionOrderField> _$gPackageVersionOrderFieldSerializer =
    new _$GPackageVersionOrderFieldSerializer();
Serializer<GPinIssueInput> _$gPinIssueInputSerializer =
    new _$GPinIssueInputSerializer();
Serializer<GPinnableItemType> _$gPinnableItemTypeSerializer =
    new _$GPinnableItemTypeSerializer();
Serializer<GPinnedDiscussionGradient> _$gPinnedDiscussionGradientSerializer =
    new _$GPinnedDiscussionGradientSerializer();
Serializer<GPinnedDiscussionPattern> _$gPinnedDiscussionPatternSerializer =
    new _$GPinnedDiscussionPatternSerializer();
Serializer<GProjectCardArchivedState> _$gProjectCardArchivedStateSerializer =
    new _$GProjectCardArchivedStateSerializer();
Serializer<GProjectCardState> _$gProjectCardStateSerializer =
    new _$GProjectCardStateSerializer();
Serializer<GProjectColumnPurpose> _$gProjectColumnPurposeSerializer =
    new _$GProjectColumnPurposeSerializer();
Serializer<GProjectOrder> _$gProjectOrderSerializer =
    new _$GProjectOrderSerializer();
Serializer<GProjectOrderField> _$gProjectOrderFieldSerializer =
    new _$GProjectOrderFieldSerializer();
Serializer<GProjectState> _$gProjectStateSerializer =
    new _$GProjectStateSerializer();
Serializer<GProjectTemplate> _$gProjectTemplateSerializer =
    new _$GProjectTemplateSerializer();
Serializer<GPullRequestMergeMethod> _$gPullRequestMergeMethodSerializer =
    new _$GPullRequestMergeMethodSerializer();
Serializer<GPullRequestOrder> _$gPullRequestOrderSerializer =
    new _$GPullRequestOrderSerializer();
Serializer<GPullRequestOrderField> _$gPullRequestOrderFieldSerializer =
    new _$GPullRequestOrderFieldSerializer();
Serializer<GPullRequestReviewCommentState>
    _$gPullRequestReviewCommentStateSerializer =
    new _$GPullRequestReviewCommentStateSerializer();
Serializer<GPullRequestReviewDecision> _$gPullRequestReviewDecisionSerializer =
    new _$GPullRequestReviewDecisionSerializer();
Serializer<GPullRequestReviewEvent> _$gPullRequestReviewEventSerializer =
    new _$GPullRequestReviewEventSerializer();
Serializer<GPullRequestReviewState> _$gPullRequestReviewStateSerializer =
    new _$GPullRequestReviewStateSerializer();
Serializer<GPullRequestState> _$gPullRequestStateSerializer =
    new _$GPullRequestStateSerializer();
Serializer<GPullRequestTimelineItemsItemType>
    _$gPullRequestTimelineItemsItemTypeSerializer =
    new _$GPullRequestTimelineItemsItemTypeSerializer();
Serializer<GPullRequestUpdateState> _$gPullRequestUpdateStateSerializer =
    new _$GPullRequestUpdateStateSerializer();
Serializer<GReactionContent> _$gReactionContentSerializer =
    new _$GReactionContentSerializer();
Serializer<GReactionOrder> _$gReactionOrderSerializer =
    new _$GReactionOrderSerializer();
Serializer<GReactionOrderField> _$gReactionOrderFieldSerializer =
    new _$GReactionOrderFieldSerializer();
Serializer<GRefOrder> _$gRefOrderSerializer = new _$GRefOrderSerializer();
Serializer<GRefOrderField> _$gRefOrderFieldSerializer =
    new _$GRefOrderFieldSerializer();
Serializer<GRegenerateEnterpriseIdentityProviderRecoveryCodesInput>
    _$gRegenerateEnterpriseIdentityProviderRecoveryCodesInputSerializer =
    new _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInputSerializer();
Serializer<GRegenerateVerifiableDomainTokenInput>
    _$gRegenerateVerifiableDomainTokenInputSerializer =
    new _$GRegenerateVerifiableDomainTokenInputSerializer();
Serializer<GRejectDeploymentsInput> _$gRejectDeploymentsInputSerializer =
    new _$GRejectDeploymentsInputSerializer();
Serializer<GReleaseOrder> _$gReleaseOrderSerializer =
    new _$GReleaseOrderSerializer();
Serializer<GReleaseOrderField> _$gReleaseOrderFieldSerializer =
    new _$GReleaseOrderFieldSerializer();
Serializer<GRemoveAssigneesFromAssignableInput>
    _$gRemoveAssigneesFromAssignableInputSerializer =
    new _$GRemoveAssigneesFromAssignableInputSerializer();
Serializer<GRemoveEnterpriseAdminInput>
    _$gRemoveEnterpriseAdminInputSerializer =
    new _$GRemoveEnterpriseAdminInputSerializer();
Serializer<GRemoveEnterpriseIdentityProviderInput>
    _$gRemoveEnterpriseIdentityProviderInputSerializer =
    new _$GRemoveEnterpriseIdentityProviderInputSerializer();
Serializer<GRemoveEnterpriseOrganizationInput>
    _$gRemoveEnterpriseOrganizationInputSerializer =
    new _$GRemoveEnterpriseOrganizationInputSerializer();
Serializer<GRemoveEnterpriseSupportEntitlementInput>
    _$gRemoveEnterpriseSupportEntitlementInputSerializer =
    new _$GRemoveEnterpriseSupportEntitlementInputSerializer();
Serializer<GRemoveLabelsFromLabelableInput>
    _$gRemoveLabelsFromLabelableInputSerializer =
    new _$GRemoveLabelsFromLabelableInputSerializer();
Serializer<GRemoveOutsideCollaboratorInput>
    _$gRemoveOutsideCollaboratorInputSerializer =
    new _$GRemoveOutsideCollaboratorInputSerializer();
Serializer<GRemoveReactionInput> _$gRemoveReactionInputSerializer =
    new _$GRemoveReactionInputSerializer();
Serializer<GRemoveStarInput> _$gRemoveStarInputSerializer =
    new _$GRemoveStarInputSerializer();
Serializer<GRemoveUpvoteInput> _$gRemoveUpvoteInputSerializer =
    new _$GRemoveUpvoteInputSerializer();
Serializer<GReopenIssueInput> _$gReopenIssueInputSerializer =
    new _$GReopenIssueInputSerializer();
Serializer<GReopenPullRequestInput> _$gReopenPullRequestInputSerializer =
    new _$GReopenPullRequestInputSerializer();
Serializer<GRepoAccessAuditEntryVisibility>
    _$gRepoAccessAuditEntryVisibilitySerializer =
    new _$GRepoAccessAuditEntryVisibilitySerializer();
Serializer<GRepoAddMemberAuditEntryVisibility>
    _$gRepoAddMemberAuditEntryVisibilitySerializer =
    new _$GRepoAddMemberAuditEntryVisibilitySerializer();
Serializer<GRepoArchivedAuditEntryVisibility>
    _$gRepoArchivedAuditEntryVisibilitySerializer =
    new _$GRepoArchivedAuditEntryVisibilitySerializer();
Serializer<GRepoChangeMergeSettingAuditEntryMergeType>
    _$gRepoChangeMergeSettingAuditEntryMergeTypeSerializer =
    new _$GRepoChangeMergeSettingAuditEntryMergeTypeSerializer();
Serializer<GRepoCreateAuditEntryVisibility>
    _$gRepoCreateAuditEntryVisibilitySerializer =
    new _$GRepoCreateAuditEntryVisibilitySerializer();
Serializer<GRepoDestroyAuditEntryVisibility>
    _$gRepoDestroyAuditEntryVisibilitySerializer =
    new _$GRepoDestroyAuditEntryVisibilitySerializer();
Serializer<GRepoRemoveMemberAuditEntryVisibility>
    _$gRepoRemoveMemberAuditEntryVisibilitySerializer =
    new _$GRepoRemoveMemberAuditEntryVisibilitySerializer();
Serializer<GReportedContentClassifiers>
    _$gReportedContentClassifiersSerializer =
    new _$GReportedContentClassifiersSerializer();
Serializer<GRepositoryAffiliation> _$gRepositoryAffiliationSerializer =
    new _$GRepositoryAffiliationSerializer();
Serializer<GRepositoryContributionType>
    _$gRepositoryContributionTypeSerializer =
    new _$GRepositoryContributionTypeSerializer();
Serializer<GRepositoryInteractionLimit>
    _$gRepositoryInteractionLimitSerializer =
    new _$GRepositoryInteractionLimitSerializer();
Serializer<GRepositoryInteractionLimitExpiry>
    _$gRepositoryInteractionLimitExpirySerializer =
    new _$GRepositoryInteractionLimitExpirySerializer();
Serializer<GRepositoryInteractionLimitOrigin>
    _$gRepositoryInteractionLimitOriginSerializer =
    new _$GRepositoryInteractionLimitOriginSerializer();
Serializer<GRepositoryInvitationOrder> _$gRepositoryInvitationOrderSerializer =
    new _$GRepositoryInvitationOrderSerializer();
Serializer<GRepositoryInvitationOrderField>
    _$gRepositoryInvitationOrderFieldSerializer =
    new _$GRepositoryInvitationOrderFieldSerializer();
Serializer<GRepositoryLockReason> _$gRepositoryLockReasonSerializer =
    new _$GRepositoryLockReasonSerializer();
Serializer<GRepositoryOrder> _$gRepositoryOrderSerializer =
    new _$GRepositoryOrderSerializer();
Serializer<GRepositoryOrderField> _$gRepositoryOrderFieldSerializer =
    new _$GRepositoryOrderFieldSerializer();
Serializer<GRepositoryPermission> _$gRepositoryPermissionSerializer =
    new _$GRepositoryPermissionSerializer();
Serializer<GRepositoryPrivacy> _$gRepositoryPrivacySerializer =
    new _$GRepositoryPrivacySerializer();
Serializer<GRepositoryVisibility> _$gRepositoryVisibilitySerializer =
    new _$GRepositoryVisibilitySerializer();
Serializer<GRequestReviewsInput> _$gRequestReviewsInputSerializer =
    new _$GRequestReviewsInputSerializer();
Serializer<GRequestableCheckStatusState>
    _$gRequestableCheckStatusStateSerializer =
    new _$GRequestableCheckStatusStateSerializer();
Serializer<GRerequestCheckSuiteInput> _$gRerequestCheckSuiteInputSerializer =
    new _$GRerequestCheckSuiteInputSerializer();
Serializer<GResolveReviewThreadInput> _$gResolveReviewThreadInputSerializer =
    new _$GResolveReviewThreadInputSerializer();
Serializer<GSamlDigestAlgorithm> _$gSamlDigestAlgorithmSerializer =
    new _$GSamlDigestAlgorithmSerializer();
Serializer<GSamlSignatureAlgorithm> _$gSamlSignatureAlgorithmSerializer =
    new _$GSamlSignatureAlgorithmSerializer();
Serializer<GSavedReplyOrder> _$gSavedReplyOrderSerializer =
    new _$GSavedReplyOrderSerializer();
Serializer<GSavedReplyOrderField> _$gSavedReplyOrderFieldSerializer =
    new _$GSavedReplyOrderFieldSerializer();
Serializer<GSearchType> _$gSearchTypeSerializer = new _$GSearchTypeSerializer();
Serializer<GSecurityAdvisoryEcosystem> _$gSecurityAdvisoryEcosystemSerializer =
    new _$GSecurityAdvisoryEcosystemSerializer();
Serializer<GSecurityAdvisoryIdentifierFilter>
    _$gSecurityAdvisoryIdentifierFilterSerializer =
    new _$GSecurityAdvisoryIdentifierFilterSerializer();
Serializer<GSecurityAdvisoryIdentifierType>
    _$gSecurityAdvisoryIdentifierTypeSerializer =
    new _$GSecurityAdvisoryIdentifierTypeSerializer();
Serializer<GSecurityAdvisoryOrder> _$gSecurityAdvisoryOrderSerializer =
    new _$GSecurityAdvisoryOrderSerializer();
Serializer<GSecurityAdvisoryOrderField>
    _$gSecurityAdvisoryOrderFieldSerializer =
    new _$GSecurityAdvisoryOrderFieldSerializer();
Serializer<GSecurityAdvisorySeverity> _$gSecurityAdvisorySeveritySerializer =
    new _$GSecurityAdvisorySeveritySerializer();
Serializer<GSecurityVulnerabilityOrder>
    _$gSecurityVulnerabilityOrderSerializer =
    new _$GSecurityVulnerabilityOrderSerializer();
Serializer<GSecurityVulnerabilityOrderField>
    _$gSecurityVulnerabilityOrderFieldSerializer =
    new _$GSecurityVulnerabilityOrderFieldSerializer();
Serializer<GSetEnterpriseIdentityProviderInput>
    _$gSetEnterpriseIdentityProviderInputSerializer =
    new _$GSetEnterpriseIdentityProviderInputSerializer();
Serializer<GSetOrganizationInteractionLimitInput>
    _$gSetOrganizationInteractionLimitInputSerializer =
    new _$GSetOrganizationInteractionLimitInputSerializer();
Serializer<GSetRepositoryInteractionLimitInput>
    _$gSetRepositoryInteractionLimitInputSerializer =
    new _$GSetRepositoryInteractionLimitInputSerializer();
Serializer<GSetUserInteractionLimitInput>
    _$gSetUserInteractionLimitInputSerializer =
    new _$GSetUserInteractionLimitInputSerializer();
Serializer<GSponsorableOrder> _$gSponsorableOrderSerializer =
    new _$GSponsorableOrderSerializer();
Serializer<GSponsorableOrderField> _$gSponsorableOrderFieldSerializer =
    new _$GSponsorableOrderFieldSerializer();
Serializer<GSponsorsGoalKind> _$gSponsorsGoalKindSerializer =
    new _$GSponsorsGoalKindSerializer();
Serializer<GSponsorsTierOrder> _$gSponsorsTierOrderSerializer =
    new _$GSponsorsTierOrderSerializer();
Serializer<GSponsorsTierOrderField> _$gSponsorsTierOrderFieldSerializer =
    new _$GSponsorsTierOrderFieldSerializer();
Serializer<GSponsorshipOrder> _$gSponsorshipOrderSerializer =
    new _$GSponsorshipOrderSerializer();
Serializer<GSponsorshipOrderField> _$gSponsorshipOrderFieldSerializer =
    new _$GSponsorshipOrderFieldSerializer();
Serializer<GSponsorshipPrivacy> _$gSponsorshipPrivacySerializer =
    new _$GSponsorshipPrivacySerializer();
Serializer<GStarOrder> _$gStarOrderSerializer = new _$GStarOrderSerializer();
Serializer<GStarOrderField> _$gStarOrderFieldSerializer =
    new _$GStarOrderFieldSerializer();
Serializer<GStatusState> _$gStatusStateSerializer =
    new _$GStatusStateSerializer();
Serializer<GSubmitPullRequestReviewInput>
    _$gSubmitPullRequestReviewInputSerializer =
    new _$GSubmitPullRequestReviewInputSerializer();
Serializer<GSubscriptionState> _$gSubscriptionStateSerializer =
    new _$GSubscriptionStateSerializer();
Serializer<GTeamDiscussionCommentOrder>
    _$gTeamDiscussionCommentOrderSerializer =
    new _$GTeamDiscussionCommentOrderSerializer();
Serializer<GTeamDiscussionCommentOrderField>
    _$gTeamDiscussionCommentOrderFieldSerializer =
    new _$GTeamDiscussionCommentOrderFieldSerializer();
Serializer<GTeamDiscussionOrder> _$gTeamDiscussionOrderSerializer =
    new _$GTeamDiscussionOrderSerializer();
Serializer<GTeamDiscussionOrderField> _$gTeamDiscussionOrderFieldSerializer =
    new _$GTeamDiscussionOrderFieldSerializer();
Serializer<GTeamMemberOrder> _$gTeamMemberOrderSerializer =
    new _$GTeamMemberOrderSerializer();
Serializer<GTeamMemberOrderField> _$gTeamMemberOrderFieldSerializer =
    new _$GTeamMemberOrderFieldSerializer();
Serializer<GTeamMemberRole> _$gTeamMemberRoleSerializer =
    new _$GTeamMemberRoleSerializer();
Serializer<GTeamMembershipType> _$gTeamMembershipTypeSerializer =
    new _$GTeamMembershipTypeSerializer();
Serializer<GTeamOrder> _$gTeamOrderSerializer = new _$GTeamOrderSerializer();
Serializer<GTeamOrderField> _$gTeamOrderFieldSerializer =
    new _$GTeamOrderFieldSerializer();
Serializer<GTeamPrivacy> _$gTeamPrivacySerializer =
    new _$GTeamPrivacySerializer();
Serializer<GTeamRepositoryOrder> _$gTeamRepositoryOrderSerializer =
    new _$GTeamRepositoryOrderSerializer();
Serializer<GTeamRepositoryOrderField> _$gTeamRepositoryOrderFieldSerializer =
    new _$GTeamRepositoryOrderFieldSerializer();
Serializer<GTeamRole> _$gTeamRoleSerializer = new _$GTeamRoleSerializer();
Serializer<GTopicSuggestionDeclineReason>
    _$gTopicSuggestionDeclineReasonSerializer =
    new _$GTopicSuggestionDeclineReasonSerializer();
Serializer<GTransferIssueInput> _$gTransferIssueInputSerializer =
    new _$GTransferIssueInputSerializer();
Serializer<GUnarchiveRepositoryInput> _$gUnarchiveRepositoryInputSerializer =
    new _$GUnarchiveRepositoryInputSerializer();
Serializer<GUnfollowUserInput> _$gUnfollowUserInputSerializer =
    new _$GUnfollowUserInputSerializer();
Serializer<GUnlinkRepositoryFromProjectInput>
    _$gUnlinkRepositoryFromProjectInputSerializer =
    new _$GUnlinkRepositoryFromProjectInputSerializer();
Serializer<GUnlockLockableInput> _$gUnlockLockableInputSerializer =
    new _$GUnlockLockableInputSerializer();
Serializer<GUnmarkDiscussionCommentAsAnswerInput>
    _$gUnmarkDiscussionCommentAsAnswerInputSerializer =
    new _$GUnmarkDiscussionCommentAsAnswerInputSerializer();
Serializer<GUnmarkFileAsViewedInput> _$gUnmarkFileAsViewedInputSerializer =
    new _$GUnmarkFileAsViewedInputSerializer();
Serializer<GUnmarkIssueAsDuplicateInput>
    _$gUnmarkIssueAsDuplicateInputSerializer =
    new _$GUnmarkIssueAsDuplicateInputSerializer();
Serializer<GUnminimizeCommentInput> _$gUnminimizeCommentInputSerializer =
    new _$GUnminimizeCommentInputSerializer();
Serializer<GUnpinIssueInput> _$gUnpinIssueInputSerializer =
    new _$GUnpinIssueInputSerializer();
Serializer<GUnresolveReviewThreadInput>
    _$gUnresolveReviewThreadInputSerializer =
    new _$GUnresolveReviewThreadInputSerializer();
Serializer<GUpdateBranchProtectionRuleInput>
    _$gUpdateBranchProtectionRuleInputSerializer =
    new _$GUpdateBranchProtectionRuleInputSerializer();
Serializer<GUpdateCheckRunInput> _$gUpdateCheckRunInputSerializer =
    new _$GUpdateCheckRunInputSerializer();
Serializer<GUpdateCheckSuitePreferencesInput>
    _$gUpdateCheckSuitePreferencesInputSerializer =
    new _$GUpdateCheckSuitePreferencesInputSerializer();
Serializer<GUpdateDiscussionCommentInput>
    _$gUpdateDiscussionCommentInputSerializer =
    new _$GUpdateDiscussionCommentInputSerializer();
Serializer<GUpdateDiscussionInput> _$gUpdateDiscussionInputSerializer =
    new _$GUpdateDiscussionInputSerializer();
Serializer<GUpdateEnterpriseAdministratorRoleInput>
    _$gUpdateEnterpriseAdministratorRoleInputSerializer =
    new _$GUpdateEnterpriseAdministratorRoleInputSerializer();
Serializer<GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput>
    _$gUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputSerializer =
    new _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputSerializer();
Serializer<GUpdateEnterpriseDefaultRepositoryPermissionSettingInput>
    _$gUpdateEnterpriseDefaultRepositoryPermissionSettingInputSerializer =
    new _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput>
    _$gUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput>
    _$gUpdateEnterpriseMembersCanCreateRepositoriesSettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanDeleteIssuesSettingInput>
    _$gUpdateEnterpriseMembersCanDeleteIssuesSettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput>
    _$gUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput>
    _$gUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanMakePurchasesSettingInput>
    _$gUpdateEnterpriseMembersCanMakePurchasesSettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanMakePurchasesSettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput>
    _$gUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputSerializer();
Serializer<GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput>
    _$gUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputSerializer =
    new _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputSerializer();
Serializer<GUpdateEnterpriseOrganizationProjectsSettingInput>
    _$gUpdateEnterpriseOrganizationProjectsSettingInputSerializer =
    new _$GUpdateEnterpriseOrganizationProjectsSettingInputSerializer();
Serializer<GUpdateEnterpriseProfileInput>
    _$gUpdateEnterpriseProfileInputSerializer =
    new _$GUpdateEnterpriseProfileInputSerializer();
Serializer<GUpdateEnterpriseRepositoryProjectsSettingInput>
    _$gUpdateEnterpriseRepositoryProjectsSettingInputSerializer =
    new _$GUpdateEnterpriseRepositoryProjectsSettingInputSerializer();
Serializer<GUpdateEnterpriseTeamDiscussionsSettingInput>
    _$gUpdateEnterpriseTeamDiscussionsSettingInputSerializer =
    new _$GUpdateEnterpriseTeamDiscussionsSettingInputSerializer();
Serializer<GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput>
    _$gUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputSerializer =
    new _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputSerializer();
Serializer<GUpdateEnvironmentInput> _$gUpdateEnvironmentInputSerializer =
    new _$GUpdateEnvironmentInputSerializer();
Serializer<GUpdateIpAllowListEnabledSettingInput>
    _$gUpdateIpAllowListEnabledSettingInputSerializer =
    new _$GUpdateIpAllowListEnabledSettingInputSerializer();
Serializer<GUpdateIpAllowListEntryInput>
    _$gUpdateIpAllowListEntryInputSerializer =
    new _$GUpdateIpAllowListEntryInputSerializer();
Serializer<GUpdateIssueCommentInput> _$gUpdateIssueCommentInputSerializer =
    new _$GUpdateIssueCommentInputSerializer();
Serializer<GUpdateIssueInput> _$gUpdateIssueInputSerializer =
    new _$GUpdateIssueInputSerializer();
Serializer<GUpdateNotificationRestrictionSettingInput>
    _$gUpdateNotificationRestrictionSettingInputSerializer =
    new _$GUpdateNotificationRestrictionSettingInputSerializer();
Serializer<GUpdateProjectCardInput> _$gUpdateProjectCardInputSerializer =
    new _$GUpdateProjectCardInputSerializer();
Serializer<GUpdateProjectColumnInput> _$gUpdateProjectColumnInputSerializer =
    new _$GUpdateProjectColumnInputSerializer();
Serializer<GUpdateProjectInput> _$gUpdateProjectInputSerializer =
    new _$GUpdateProjectInputSerializer();
Serializer<GUpdatePullRequestInput> _$gUpdatePullRequestInputSerializer =
    new _$GUpdatePullRequestInputSerializer();
Serializer<GUpdatePullRequestReviewCommentInput>
    _$gUpdatePullRequestReviewCommentInputSerializer =
    new _$GUpdatePullRequestReviewCommentInputSerializer();
Serializer<GUpdatePullRequestReviewInput>
    _$gUpdatePullRequestReviewInputSerializer =
    new _$GUpdatePullRequestReviewInputSerializer();
Serializer<GUpdateRefInput> _$gUpdateRefInputSerializer =
    new _$GUpdateRefInputSerializer();
Serializer<GUpdateRepositoryInput> _$gUpdateRepositoryInputSerializer =
    new _$GUpdateRepositoryInputSerializer();
Serializer<GUpdateSubscriptionInput> _$gUpdateSubscriptionInputSerializer =
    new _$GUpdateSubscriptionInputSerializer();
Serializer<GUpdateTeamDiscussionCommentInput>
    _$gUpdateTeamDiscussionCommentInputSerializer =
    new _$GUpdateTeamDiscussionCommentInputSerializer();
Serializer<GUpdateTeamDiscussionInput> _$gUpdateTeamDiscussionInputSerializer =
    new _$GUpdateTeamDiscussionInputSerializer();
Serializer<GUpdateTopicsInput> _$gUpdateTopicsInputSerializer =
    new _$GUpdateTopicsInputSerializer();
Serializer<GUserBlockDuration> _$gUserBlockDurationSerializer =
    new _$GUserBlockDurationSerializer();
Serializer<GUserStatusOrder> _$gUserStatusOrderSerializer =
    new _$GUserStatusOrderSerializer();
Serializer<GUserStatusOrderField> _$gUserStatusOrderFieldSerializer =
    new _$GUserStatusOrderFieldSerializer();
Serializer<GVerifiableDomainOrder> _$gVerifiableDomainOrderSerializer =
    new _$GVerifiableDomainOrderSerializer();
Serializer<GVerifiableDomainOrderField>
    _$gVerifiableDomainOrderFieldSerializer =
    new _$GVerifiableDomainOrderFieldSerializer();
Serializer<GVerifyVerifiableDomainInput>
    _$gVerifyVerifiableDomainInputSerializer =
    new _$GVerifyVerifiableDomainInputSerializer();

class _$GAcceptEnterpriseAdministratorInvitationInputSerializer
    implements
        StructuredSerializer<GAcceptEnterpriseAdministratorInvitationInput> {
  @override
  final Iterable<Type> types = const [
    GAcceptEnterpriseAdministratorInvitationInput,
    _$GAcceptEnterpriseAdministratorInvitationInput
  ];
  @override
  final String wireName = 'GAcceptEnterpriseAdministratorInvitationInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GAcceptEnterpriseAdministratorInvitationInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'invitationId',
      serializers.serialize(object.invitationId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAcceptEnterpriseAdministratorInvitationInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAcceptEnterpriseAdministratorInvitationInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'invitationId':
          result.invitationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAcceptTopicSuggestionInputSerializer
    implements StructuredSerializer<GAcceptTopicSuggestionInput> {
  @override
  final Iterable<Type> types = const [
    GAcceptTopicSuggestionInput,
    _$GAcceptTopicSuggestionInput
  ];
  @override
  final String wireName = 'GAcceptTopicSuggestionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAcceptTopicSuggestionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAcceptTopicSuggestionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAcceptTopicSuggestionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddAssigneesToAssignableInputSerializer
    implements StructuredSerializer<GAddAssigneesToAssignableInput> {
  @override
  final Iterable<Type> types = const [
    GAddAssigneesToAssignableInput,
    _$GAddAssigneesToAssignableInput
  ];
  @override
  final String wireName = 'GAddAssigneesToAssignableInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddAssigneesToAssignableInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'assignableId',
      serializers.serialize(object.assignableId,
          specifiedType: const FullType(String)),
      'assigneeIds',
      serializers.serialize(object.assigneeIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddAssigneesToAssignableInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddAssigneesToAssignableInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'assignableId':
          result.assignableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'assigneeIds':
          result.assigneeIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddCommentInputSerializer
    implements StructuredSerializer<GAddCommentInput> {
  @override
  final Iterable<Type> types = const [GAddCommentInput, _$GAddCommentInput];
  @override
  final String wireName = 'GAddCommentInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GAddCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'subjectId',
      serializers.serialize(object.subjectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'subjectId':
          result.subjectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddDiscussionCommentInputSerializer
    implements StructuredSerializer<GAddDiscussionCommentInput> {
  @override
  final Iterable<Type> types = const [
    GAddDiscussionCommentInput,
    _$GAddDiscussionCommentInput
  ];
  @override
  final String wireName = 'GAddDiscussionCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddDiscussionCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'discussionId',
      serializers.serialize(object.discussionId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.replyToId;
    if (value != null) {
      result
        ..add('replyToId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddDiscussionCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddDiscussionCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'discussionId':
          result.discussionId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'replyToId':
          result.replyToId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddEnterpriseSupportEntitlementInputSerializer
    implements StructuredSerializer<GAddEnterpriseSupportEntitlementInput> {
  @override
  final Iterable<Type> types = const [
    GAddEnterpriseSupportEntitlementInput,
    _$GAddEnterpriseSupportEntitlementInput
  ];
  @override
  final String wireName = 'GAddEnterpriseSupportEntitlementInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddEnterpriseSupportEntitlementInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'login',
      serializers.serialize(object.login,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddEnterpriseSupportEntitlementInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddEnterpriseSupportEntitlementInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'login':
          result.login = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddLabelsToLabelableInputSerializer
    implements StructuredSerializer<GAddLabelsToLabelableInput> {
  @override
  final Iterable<Type> types = const [
    GAddLabelsToLabelableInput,
    _$GAddLabelsToLabelableInput
  ];
  @override
  final String wireName = 'GAddLabelsToLabelableInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddLabelsToLabelableInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'labelIds',
      serializers.serialize(object.labelIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'labelableId',
      serializers.serialize(object.labelableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddLabelsToLabelableInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddLabelsToLabelableInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'labelIds':
          result.labelIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'labelableId':
          result.labelableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddProjectCardInputSerializer
    implements StructuredSerializer<GAddProjectCardInput> {
  @override
  final Iterable<Type> types = const [
    GAddProjectCardInput,
    _$GAddProjectCardInput
  ];
  @override
  final String wireName = 'GAddProjectCardInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddProjectCardInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'projectColumnId',
      serializers.serialize(object.projectColumnId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.contentId;
    if (value != null) {
      result
        ..add('contentId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.note;
    if (value != null) {
      result
        ..add('note')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddProjectCardInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddProjectCardInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'contentId':
          result.contentId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'note':
          result.note = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectColumnId':
          result.projectColumnId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddProjectColumnInputSerializer
    implements StructuredSerializer<GAddProjectColumnInput> {
  @override
  final Iterable<Type> types = const [
    GAddProjectColumnInput,
    _$GAddProjectColumnInput
  ];
  @override
  final String wireName = 'GAddProjectColumnInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddProjectColumnInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'projectId',
      serializers.serialize(object.projectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddProjectColumnInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddProjectColumnInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectId':
          result.projectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddPullRequestReviewCommentInputSerializer
    implements StructuredSerializer<GAddPullRequestReviewCommentInput> {
  @override
  final Iterable<Type> types = const [
    GAddPullRequestReviewCommentInput,
    _$GAddPullRequestReviewCommentInput
  ];
  @override
  final String wireName = 'GAddPullRequestReviewCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddPullRequestReviewCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.commitOID;
    if (value != null) {
      result
        ..add('commitOID')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.inReplyTo;
    if (value != null) {
      result
        ..add('inReplyTo')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.path;
    if (value != null) {
      result
        ..add('path')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.position;
    if (value != null) {
      result
        ..add('position')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.pullRequestId;
    if (value != null) {
      result
        ..add('pullRequestId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.pullRequestReviewId;
    if (value != null) {
      result
        ..add('pullRequestReviewId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddPullRequestReviewCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddPullRequestReviewCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'commitOID':
          result.commitOID = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'inReplyTo':
          result.inReplyTo = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'path':
          result.path = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'position':
          result.position = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestReviewId':
          result.pullRequestReviewId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddPullRequestReviewInputSerializer
    implements StructuredSerializer<GAddPullRequestReviewInput> {
  @override
  final Iterable<Type> types = const [
    GAddPullRequestReviewInput,
    _$GAddPullRequestReviewInput
  ];
  @override
  final String wireName = 'GAddPullRequestReviewInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddPullRequestReviewInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.comments;
    if (value != null) {
      result
        ..add('comments')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(BuiltList,
                const [const FullType(GDraftPullRequestReviewComment)])));
    }
    value = object.commitOID;
    if (value != null) {
      result
        ..add('commitOID')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.event;
    if (value != null) {
      result
        ..add('event')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GPullRequestReviewEvent)));
    }
    value = object.threads;
    if (value != null) {
      result
        ..add('threads')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(BuiltList,
                const [const FullType(GDraftPullRequestReviewThread)])));
    }
    return result;
  }

  @override
  GAddPullRequestReviewInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddPullRequestReviewInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'comments':
          result.comments.replace(serializers.deserialize(value,
              specifiedType: const FullType(BuiltList, const [
                const FullType(GDraftPullRequestReviewComment)
              ]))! as BuiltList<Object>);
          break;
        case 'commitOID':
          result.commitOID = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'event':
          result.event = serializers.deserialize(value,
                  specifiedType: const FullType(GPullRequestReviewEvent))
              as GPullRequestReviewEvent;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'threads':
          result.threads.replace(serializers.deserialize(value,
              specifiedType: const FullType(BuiltList, const [
                const FullType(GDraftPullRequestReviewThread)
              ]))! as BuiltList<Object>);
          break;
      }
    }

    return result.build();
  }
}

class _$GAddPullRequestReviewThreadInputSerializer
    implements StructuredSerializer<GAddPullRequestReviewThreadInput> {
  @override
  final Iterable<Type> types = const [
    GAddPullRequestReviewThreadInput,
    _$GAddPullRequestReviewThreadInput
  ];
  @override
  final String wireName = 'GAddPullRequestReviewThreadInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddPullRequestReviewThreadInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'line',
      serializers.serialize(object.line, specifiedType: const FullType(int)),
      'path',
      serializers.serialize(object.path, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.pullRequestId;
    if (value != null) {
      result
        ..add('pullRequestId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.pullRequestReviewId;
    if (value != null) {
      result
        ..add('pullRequestReviewId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.side;
    if (value != null) {
      result
        ..add('side')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GDiffSide)));
    }
    value = object.startLine;
    if (value != null) {
      result
        ..add('startLine')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.startSide;
    if (value != null) {
      result
        ..add('startSide')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GDiffSide)));
    }
    return result;
  }

  @override
  GAddPullRequestReviewThreadInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddPullRequestReviewThreadInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'line':
          result.line = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'path':
          result.path = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestReviewId':
          result.pullRequestReviewId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'side':
          result.side = serializers.deserialize(value,
              specifiedType: const FullType(GDiffSide)) as GDiffSide;
          break;
        case 'startLine':
          result.startLine = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'startSide':
          result.startSide = serializers.deserialize(value,
              specifiedType: const FullType(GDiffSide)) as GDiffSide;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddReactionInputSerializer
    implements StructuredSerializer<GAddReactionInput> {
  @override
  final Iterable<Type> types = const [GAddReactionInput, _$GAddReactionInput];
  @override
  final String wireName = 'GAddReactionInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GAddReactionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'content',
      serializers.serialize(object.content,
          specifiedType: const FullType(GReactionContent)),
      'subjectId',
      serializers.serialize(object.subjectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddReactionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddReactionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'content':
          result.content = serializers.deserialize(value,
                  specifiedType: const FullType(GReactionContent))
              as GReactionContent;
          break;
        case 'subjectId':
          result.subjectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddStarInputSerializer implements StructuredSerializer<GAddStarInput> {
  @override
  final Iterable<Type> types = const [GAddStarInput, _$GAddStarInput];
  @override
  final String wireName = 'GAddStarInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GAddStarInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'starrableId',
      serializers.serialize(object.starrableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddStarInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddStarInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'starrableId':
          result.starrableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddUpvoteInputSerializer
    implements StructuredSerializer<GAddUpvoteInput> {
  @override
  final Iterable<Type> types = const [GAddUpvoteInput, _$GAddUpvoteInput];
  @override
  final String wireName = 'GAddUpvoteInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GAddUpvoteInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'subjectId',
      serializers.serialize(object.subjectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddUpvoteInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddUpvoteInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'subjectId':
          result.subjectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAddVerifiableDomainInputSerializer
    implements StructuredSerializer<GAddVerifiableDomainInput> {
  @override
  final Iterable<Type> types = const [
    GAddVerifiableDomainInput,
    _$GAddVerifiableDomainInput
  ];
  @override
  final String wireName = 'GAddVerifiableDomainInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GAddVerifiableDomainInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'domain',
      serializers.serialize(object.domain,
          specifiedType: const FullType(String)),
      'ownerId',
      serializers.serialize(object.ownerId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GAddVerifiableDomainInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAddVerifiableDomainInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'domain':
          result.domain = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ownerId':
          result.ownerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GApproveDeploymentsInputSerializer
    implements StructuredSerializer<GApproveDeploymentsInput> {
  @override
  final Iterable<Type> types = const [
    GApproveDeploymentsInput,
    _$GApproveDeploymentsInput
  ];
  @override
  final String wireName = 'GApproveDeploymentsInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GApproveDeploymentsInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'environmentIds',
      serializers.serialize(object.environmentIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'workflowRunId',
      serializers.serialize(object.workflowRunId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.comment;
    if (value != null) {
      result
        ..add('comment')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GApproveDeploymentsInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GApproveDeploymentsInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'comment':
          result.comment = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'environmentIds':
          result.environmentIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'workflowRunId':
          result.workflowRunId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GApproveVerifiableDomainInputSerializer
    implements StructuredSerializer<GApproveVerifiableDomainInput> {
  @override
  final Iterable<Type> types = const [
    GApproveVerifiableDomainInput,
    _$GApproveVerifiableDomainInput
  ];
  @override
  final String wireName = 'GApproveVerifiableDomainInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GApproveVerifiableDomainInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GApproveVerifiableDomainInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GApproveVerifiableDomainInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GArchiveRepositoryInputSerializer
    implements StructuredSerializer<GArchiveRepositoryInput> {
  @override
  final Iterable<Type> types = const [
    GArchiveRepositoryInput,
    _$GArchiveRepositoryInput
  ];
  @override
  final String wireName = 'GArchiveRepositoryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GArchiveRepositoryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GArchiveRepositoryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GArchiveRepositoryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAuditLogOrderSerializer
    implements StructuredSerializer<GAuditLogOrder> {
  @override
  final Iterable<Type> types = const [GAuditLogOrder, _$GAuditLogOrder];
  @override
  final String wireName = 'GAuditLogOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GAuditLogOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.direction;
    if (value != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GOrderDirection)));
    }
    value = object.field;
    if (value != null) {
      result
        ..add('field')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GAuditLogOrderField)));
    }
    return result;
  }

  @override
  GAuditLogOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GAuditLogOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GAuditLogOrderField))
              as GAuditLogOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GAuditLogOrderFieldSerializer
    implements PrimitiveSerializer<GAuditLogOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GAuditLogOrderField];
  @override
  final String wireName = 'GAuditLogOrderField';

  @override
  Object serialize(Serializers serializers, GAuditLogOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GAuditLogOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GAuditLogOrderField.valueOf(serialized as String);
}

class _$GCancelEnterpriseAdminInvitationInputSerializer
    implements StructuredSerializer<GCancelEnterpriseAdminInvitationInput> {
  @override
  final Iterable<Type> types = const [
    GCancelEnterpriseAdminInvitationInput,
    _$GCancelEnterpriseAdminInvitationInput
  ];
  @override
  final String wireName = 'GCancelEnterpriseAdminInvitationInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCancelEnterpriseAdminInvitationInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'invitationId',
      serializers.serialize(object.invitationId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCancelEnterpriseAdminInvitationInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCancelEnterpriseAdminInvitationInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'invitationId':
          result.invitationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GChangeUserStatusInputSerializer
    implements StructuredSerializer<GChangeUserStatusInput> {
  @override
  final Iterable<Type> types = const [
    GChangeUserStatusInput,
    _$GChangeUserStatusInput
  ];
  @override
  final String wireName = 'GChangeUserStatusInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GChangeUserStatusInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.emoji;
    if (value != null) {
      result
        ..add('emoji')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.expiresAt;
    if (value != null) {
      result
        ..add('expiresAt')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(DateTime)));
    }
    value = object.limitedAvailability;
    if (value != null) {
      result
        ..add('limitedAvailability')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.message;
    if (value != null) {
      result
        ..add('message')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.organizationId;
    if (value != null) {
      result
        ..add('organizationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GChangeUserStatusInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GChangeUserStatusInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'emoji':
          result.emoji = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'expiresAt':
          result.expiresAt = serializers.deserialize(value,
              specifiedType: const FullType(DateTime)) as DateTime;
          break;
        case 'limitedAvailability':
          result.limitedAvailability = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'message':
          result.message = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'organizationId':
          result.organizationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckAnnotationDataSerializer
    implements StructuredSerializer<GCheckAnnotationData> {
  @override
  final Iterable<Type> types = const [
    GCheckAnnotationData,
    _$GCheckAnnotationData
  ];
  @override
  final String wireName = 'GCheckAnnotationData';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCheckAnnotationData object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'annotationLevel',
      serializers.serialize(object.annotationLevel,
          specifiedType: const FullType(GCheckAnnotationLevel)),
      'location',
      serializers.serialize(object.location,
          specifiedType: const FullType(GCheckAnnotationRange)),
      'message',
      serializers.serialize(object.message,
          specifiedType: const FullType(String)),
      'path',
      serializers.serialize(object.path, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.rawDetails;
    if (value != null) {
      result
        ..add('rawDetails')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.title;
    if (value != null) {
      result
        ..add('title')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCheckAnnotationData deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckAnnotationDataBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'annotationLevel':
          result.annotationLevel = serializers.deserialize(value,
                  specifiedType: const FullType(GCheckAnnotationLevel))
              as GCheckAnnotationLevel;
          break;
        case 'location':
          result.location.replace(serializers.deserialize(value,
                  specifiedType: const FullType(GCheckAnnotationRange))!
              as GCheckAnnotationRange);
          break;
        case 'message':
          result.message = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'path':
          result.path = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'rawDetails':
          result.rawDetails = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckAnnotationLevelSerializer
    implements PrimitiveSerializer<GCheckAnnotationLevel> {
  @override
  final Iterable<Type> types = const <Type>[GCheckAnnotationLevel];
  @override
  final String wireName = 'GCheckAnnotationLevel';

  @override
  Object serialize(Serializers serializers, GCheckAnnotationLevel object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCheckAnnotationLevel deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCheckAnnotationLevel.valueOf(serialized as String);
}

class _$GCheckAnnotationRangeSerializer
    implements StructuredSerializer<GCheckAnnotationRange> {
  @override
  final Iterable<Type> types = const [
    GCheckAnnotationRange,
    _$GCheckAnnotationRange
  ];
  @override
  final String wireName = 'GCheckAnnotationRange';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCheckAnnotationRange object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'endLine',
      serializers.serialize(object.endLine, specifiedType: const FullType(int)),
      'startLine',
      serializers.serialize(object.startLine,
          specifiedType: const FullType(int)),
    ];
    Object? value;
    value = object.endColumn;
    if (value != null) {
      result
        ..add('endColumn')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.startColumn;
    if (value != null) {
      result
        ..add('startColumn')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    return result;
  }

  @override
  GCheckAnnotationRange deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckAnnotationRangeBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'endColumn':
          result.endColumn = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'endLine':
          result.endLine = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'startColumn':
          result.startColumn = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'startLine':
          result.startLine = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckConclusionStateSerializer
    implements PrimitiveSerializer<GCheckConclusionState> {
  @override
  final Iterable<Type> types = const <Type>[GCheckConclusionState];
  @override
  final String wireName = 'GCheckConclusionState';

  @override
  Object serialize(Serializers serializers, GCheckConclusionState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCheckConclusionState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCheckConclusionState.valueOf(serialized as String);
}

class _$GCheckRunActionSerializer
    implements StructuredSerializer<GCheckRunAction> {
  @override
  final Iterable<Type> types = const [GCheckRunAction, _$GCheckRunAction];
  @override
  final String wireName = 'GCheckRunAction';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCheckRunAction object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'description',
      serializers.serialize(object.description,
          specifiedType: const FullType(String)),
      'identifier',
      serializers.serialize(object.identifier,
          specifiedType: const FullType(String)),
      'label',
      serializers.serialize(object.label,
          specifiedType: const FullType(String)),
    ];

    return result;
  }

  @override
  GCheckRunAction deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckRunActionBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'description':
          result.description = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'identifier':
          result.identifier = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'label':
          result.label = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckRunFilterSerializer
    implements StructuredSerializer<GCheckRunFilter> {
  @override
  final Iterable<Type> types = const [GCheckRunFilter, _$GCheckRunFilter];
  @override
  final String wireName = 'GCheckRunFilter';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCheckRunFilter object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.appId;
    if (value != null) {
      result
        ..add('appId')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.checkName;
    if (value != null) {
      result
        ..add('checkName')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.checkType;
    if (value != null) {
      result
        ..add('checkType')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GCheckRunType)));
    }
    value = object.status;
    if (value != null) {
      result
        ..add('status')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GCheckStatusState)));
    }
    return result;
  }

  @override
  GCheckRunFilter deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckRunFilterBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'appId':
          result.appId = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'checkName':
          result.checkName = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'checkType':
          result.checkType = serializers.deserialize(value,
              specifiedType: const FullType(GCheckRunType)) as GCheckRunType;
          break;
        case 'status':
          result.status = serializers.deserialize(value,
                  specifiedType: const FullType(GCheckStatusState))
              as GCheckStatusState;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckRunOutputSerializer
    implements StructuredSerializer<GCheckRunOutput> {
  @override
  final Iterable<Type> types = const [GCheckRunOutput, _$GCheckRunOutput];
  @override
  final String wireName = 'GCheckRunOutput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCheckRunOutput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'summary',
      serializers.serialize(object.summary,
          specifiedType: const FullType(String)),
      'title',
      serializers.serialize(object.title,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.annotations;
    if (value != null) {
      result
        ..add('annotations')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(
                BuiltList, const [const FullType(GCheckAnnotationData)])));
    }
    value = object.images;
    if (value != null) {
      result
        ..add('images')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(
                BuiltList, const [const FullType(GCheckRunOutputImage)])));
    }
    value = object.text;
    if (value != null) {
      result
        ..add('text')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCheckRunOutput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckRunOutputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'annotations':
          result.annotations.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(GCheckAnnotationData)]))!
              as BuiltList<Object>);
          break;
        case 'images':
          result.images.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(GCheckRunOutputImage)]))!
              as BuiltList<Object>);
          break;
        case 'summary':
          result.summary = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'text':
          result.text = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckRunOutputImageSerializer
    implements StructuredSerializer<GCheckRunOutputImage> {
  @override
  final Iterable<Type> types = const [
    GCheckRunOutputImage,
    _$GCheckRunOutputImage
  ];
  @override
  final String wireName = 'GCheckRunOutputImage';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCheckRunOutputImage object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'alt',
      serializers.serialize(object.alt, specifiedType: const FullType(String)),
      'imageUrl',
      serializers.serialize(object.imageUrl,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.caption;
    if (value != null) {
      result
        ..add('caption')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCheckRunOutputImage deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckRunOutputImageBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'alt':
          result.alt = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'caption':
          result.caption = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'imageUrl':
          result.imageUrl = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckRunTypeSerializer implements PrimitiveSerializer<GCheckRunType> {
  @override
  final Iterable<Type> types = const <Type>[GCheckRunType];
  @override
  final String wireName = 'GCheckRunType';

  @override
  Object serialize(Serializers serializers, GCheckRunType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCheckRunType deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCheckRunType.valueOf(serialized as String);
}

class _$GCheckStatusStateSerializer
    implements PrimitiveSerializer<GCheckStatusState> {
  @override
  final Iterable<Type> types = const <Type>[GCheckStatusState];
  @override
  final String wireName = 'GCheckStatusState';

  @override
  Object serialize(Serializers serializers, GCheckStatusState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCheckStatusState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCheckStatusState.valueOf(serialized as String);
}

class _$GCheckSuiteAutoTriggerPreferenceSerializer
    implements StructuredSerializer<GCheckSuiteAutoTriggerPreference> {
  @override
  final Iterable<Type> types = const [
    GCheckSuiteAutoTriggerPreference,
    _$GCheckSuiteAutoTriggerPreference
  ];
  @override
  final String wireName = 'GCheckSuiteAutoTriggerPreference';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCheckSuiteAutoTriggerPreference object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'appId',
      serializers.serialize(object.appId,
          specifiedType: const FullType(String)),
      'setting',
      serializers.serialize(object.setting,
          specifiedType: const FullType(bool)),
    ];

    return result;
  }

  @override
  GCheckSuiteAutoTriggerPreference deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckSuiteAutoTriggerPreferenceBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'appId':
          result.appId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'setting':
          result.setting = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
      }
    }

    return result.build();
  }
}

class _$GCheckSuiteFilterSerializer
    implements StructuredSerializer<GCheckSuiteFilter> {
  @override
  final Iterable<Type> types = const [GCheckSuiteFilter, _$GCheckSuiteFilter];
  @override
  final String wireName = 'GCheckSuiteFilter';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCheckSuiteFilter object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.appId;
    if (value != null) {
      result
        ..add('appId')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.checkName;
    if (value != null) {
      result
        ..add('checkName')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCheckSuiteFilter deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCheckSuiteFilterBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'appId':
          result.appId = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'checkName':
          result.checkName = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GClearLabelsFromLabelableInputSerializer
    implements StructuredSerializer<GClearLabelsFromLabelableInput> {
  @override
  final Iterable<Type> types = const [
    GClearLabelsFromLabelableInput,
    _$GClearLabelsFromLabelableInput
  ];
  @override
  final String wireName = 'GClearLabelsFromLabelableInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GClearLabelsFromLabelableInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'labelableId',
      serializers.serialize(object.labelableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GClearLabelsFromLabelableInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GClearLabelsFromLabelableInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'labelableId':
          result.labelableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCloneProjectInputSerializer
    implements StructuredSerializer<GCloneProjectInput> {
  @override
  final Iterable<Type> types = const [GCloneProjectInput, _$GCloneProjectInput];
  @override
  final String wireName = 'GCloneProjectInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCloneProjectInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'includeWorkflows',
      serializers.serialize(object.includeWorkflows,
          specifiedType: const FullType(bool)),
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'sourceId',
      serializers.serialize(object.sourceId,
          specifiedType: const FullType(String)),
      'targetOwnerId',
      serializers.serialize(object.targetOwnerId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.public;
    if (value != null) {
      result
        ..add('public')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GCloneProjectInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCloneProjectInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'includeWorkflows':
          result.includeWorkflows = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'public':
          result.public = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'sourceId':
          result.sourceId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'targetOwnerId':
          result.targetOwnerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCloneTemplateRepositoryInputSerializer
    implements StructuredSerializer<GCloneTemplateRepositoryInput> {
  @override
  final Iterable<Type> types = const [
    GCloneTemplateRepositoryInput,
    _$GCloneTemplateRepositoryInput
  ];
  @override
  final String wireName = 'GCloneTemplateRepositoryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCloneTemplateRepositoryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'ownerId',
      serializers.serialize(object.ownerId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
      'visibility',
      serializers.serialize(object.visibility,
          specifiedType: const FullType(GRepositoryVisibility)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.description;
    if (value != null) {
      result
        ..add('description')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.includeAllBranches;
    if (value != null) {
      result
        ..add('includeAllBranches')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GCloneTemplateRepositoryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCloneTemplateRepositoryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'description':
          result.description = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'includeAllBranches':
          result.includeAllBranches = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ownerId':
          result.ownerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'visibility':
          result.visibility = serializers.deserialize(value,
                  specifiedType: const FullType(GRepositoryVisibility))
              as GRepositoryVisibility;
          break;
      }
    }

    return result.build();
  }
}

class _$GCloseIssueInputSerializer
    implements StructuredSerializer<GCloseIssueInput> {
  @override
  final Iterable<Type> types = const [GCloseIssueInput, _$GCloseIssueInput];
  @override
  final String wireName = 'GCloseIssueInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCloseIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'issueId',
      serializers.serialize(object.issueId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCloseIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCloseIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issueId':
          result.issueId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GClosePullRequestInputSerializer
    implements StructuredSerializer<GClosePullRequestInput> {
  @override
  final Iterable<Type> types = const [
    GClosePullRequestInput,
    _$GClosePullRequestInput
  ];
  @override
  final String wireName = 'GClosePullRequestInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GClosePullRequestInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GClosePullRequestInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GClosePullRequestInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCollaboratorAffiliationSerializer
    implements PrimitiveSerializer<GCollaboratorAffiliation> {
  @override
  final Iterable<Type> types = const <Type>[GCollaboratorAffiliation];
  @override
  final String wireName = 'GCollaboratorAffiliation';

  @override
  Object serialize(Serializers serializers, GCollaboratorAffiliation object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCollaboratorAffiliation deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCollaboratorAffiliation.valueOf(serialized as String);
}

class _$GCommentAuthorAssociationSerializer
    implements PrimitiveSerializer<GCommentAuthorAssociation> {
  @override
  final Iterable<Type> types = const <Type>[GCommentAuthorAssociation];
  @override
  final String wireName = 'GCommentAuthorAssociation';

  @override
  Object serialize(Serializers serializers, GCommentAuthorAssociation object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCommentAuthorAssociation deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCommentAuthorAssociation.valueOf(serialized as String);
}

class _$GCommentCannotUpdateReasonSerializer
    implements PrimitiveSerializer<GCommentCannotUpdateReason> {
  @override
  final Iterable<Type> types = const <Type>[GCommentCannotUpdateReason];
  @override
  final String wireName = 'GCommentCannotUpdateReason';

  @override
  Object serialize(Serializers serializers, GCommentCannotUpdateReason object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCommentCannotUpdateReason deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCommentCannotUpdateReason.valueOf(serialized as String);
}

class _$GCommitAuthorSerializer implements StructuredSerializer<GCommitAuthor> {
  @override
  final Iterable<Type> types = const [GCommitAuthor, _$GCommitAuthor];
  @override
  final String wireName = 'GCommitAuthor';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCommitAuthor object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.emails;
    if (value != null) {
      result
        ..add('emails')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.id;
    if (value != null) {
      result
        ..add('id')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCommitAuthor deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCommitAuthorBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'emails':
          result.emails.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCommitContributionOrderSerializer
    implements StructuredSerializer<GCommitContributionOrder> {
  @override
  final Iterable<Type> types = const [
    GCommitContributionOrder,
    _$GCommitContributionOrder
  ];
  @override
  final String wireName = 'GCommitContributionOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCommitContributionOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GCommitContributionOrderField)),
    ];

    return result;
  }

  @override
  GCommitContributionOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCommitContributionOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GCommitContributionOrderField))
              as GCommitContributionOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GCommitContributionOrderFieldSerializer
    implements PrimitiveSerializer<GCommitContributionOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GCommitContributionOrderField];
  @override
  final String wireName = 'GCommitContributionOrderField';

  @override
  Object serialize(
          Serializers serializers, GCommitContributionOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GCommitContributionOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GCommitContributionOrderField.valueOf(serialized as String);
}

class _$GContributionLevelSerializer
    implements PrimitiveSerializer<GContributionLevel> {
  @override
  final Iterable<Type> types = const <Type>[GContributionLevel];
  @override
  final String wireName = 'GContributionLevel';

  @override
  Object serialize(Serializers serializers, GContributionLevel object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GContributionLevel deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GContributionLevel.valueOf(serialized as String);
}

class _$GContributionOrderSerializer
    implements StructuredSerializer<GContributionOrder> {
  @override
  final Iterable<Type> types = const [GContributionOrder, _$GContributionOrder];
  @override
  final String wireName = 'GContributionOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GContributionOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
    ];

    return result;
  }

  @override
  GContributionOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GContributionOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
      }
    }

    return result.build();
  }
}

class _$GConvertProjectCardNoteToIssueInputSerializer
    implements StructuredSerializer<GConvertProjectCardNoteToIssueInput> {
  @override
  final Iterable<Type> types = const [
    GConvertProjectCardNoteToIssueInput,
    _$GConvertProjectCardNoteToIssueInput
  ];
  @override
  final String wireName = 'GConvertProjectCardNoteToIssueInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GConvertProjectCardNoteToIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'projectCardId',
      serializers.serialize(object.projectCardId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.title;
    if (value != null) {
      result
        ..add('title')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GConvertProjectCardNoteToIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GConvertProjectCardNoteToIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectCardId':
          result.projectCardId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GConvertPullRequestToDraftInputSerializer
    implements StructuredSerializer<GConvertPullRequestToDraftInput> {
  @override
  final Iterable<Type> types = const [
    GConvertPullRequestToDraftInput,
    _$GConvertPullRequestToDraftInput
  ];
  @override
  final String wireName = 'GConvertPullRequestToDraftInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GConvertPullRequestToDraftInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GConvertPullRequestToDraftInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GConvertPullRequestToDraftInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateBranchProtectionRuleInputSerializer
    implements StructuredSerializer<GCreateBranchProtectionRuleInput> {
  @override
  final Iterable<Type> types = const [
    GCreateBranchProtectionRuleInput,
    _$GCreateBranchProtectionRuleInput
  ];
  @override
  final String wireName = 'GCreateBranchProtectionRuleInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateBranchProtectionRuleInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pattern',
      serializers.serialize(object.pattern,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.allowsDeletions;
    if (value != null) {
      result
        ..add('allowsDeletions')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.allowsForcePushes;
    if (value != null) {
      result
        ..add('allowsForcePushes')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.dismissesStaleReviews;
    if (value != null) {
      result
        ..add('dismissesStaleReviews')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.isAdminEnforced;
    if (value != null) {
      result
        ..add('isAdminEnforced')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.pushActorIds;
    if (value != null) {
      result
        ..add('pushActorIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.requiredApprovingReviewCount;
    if (value != null) {
      result
        ..add('requiredApprovingReviewCount')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.requiredStatusCheckContexts;
    if (value != null) {
      result
        ..add('requiredStatusCheckContexts')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.requiresApprovingReviews;
    if (value != null) {
      result
        ..add('requiresApprovingReviews')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresCodeOwnerReviews;
    if (value != null) {
      result
        ..add('requiresCodeOwnerReviews')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresCommitSignatures;
    if (value != null) {
      result
        ..add('requiresCommitSignatures')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresLinearHistory;
    if (value != null) {
      result
        ..add('requiresLinearHistory')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresStatusChecks;
    if (value != null) {
      result
        ..add('requiresStatusChecks')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresStrictStatusChecks;
    if (value != null) {
      result
        ..add('requiresStrictStatusChecks')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.restrictsPushes;
    if (value != null) {
      result
        ..add('restrictsPushes')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.restrictsReviewDismissals;
    if (value != null) {
      result
        ..add('restrictsReviewDismissals')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.reviewDismissalActorIds;
    if (value != null) {
      result
        ..add('reviewDismissalActorIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    return result;
  }

  @override
  GCreateBranchProtectionRuleInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateBranchProtectionRuleInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'allowsDeletions':
          result.allowsDeletions = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'allowsForcePushes':
          result.allowsForcePushes = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'dismissesStaleReviews':
          result.dismissesStaleReviews = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'isAdminEnforced':
          result.isAdminEnforced = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'pattern':
          result.pattern = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pushActorIds':
          result.pushActorIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'requiredApprovingReviewCount':
          result.requiredApprovingReviewCount = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'requiredStatusCheckContexts':
          result.requiredStatusCheckContexts.replace(serializers.deserialize(
                  value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'requiresApprovingReviews':
          result.requiresApprovingReviews = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresCodeOwnerReviews':
          result.requiresCodeOwnerReviews = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresCommitSignatures':
          result.requiresCommitSignatures = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresLinearHistory':
          result.requiresLinearHistory = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresStatusChecks':
          result.requiresStatusChecks = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresStrictStatusChecks':
          result.requiresStrictStatusChecks = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'restrictsPushes':
          result.restrictsPushes = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'restrictsReviewDismissals':
          result.restrictsReviewDismissals = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'reviewDismissalActorIds':
          result.reviewDismissalActorIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateCheckRunInputSerializer
    implements StructuredSerializer<GCreateCheckRunInput> {
  @override
  final Iterable<Type> types = const [
    GCreateCheckRunInput,
    _$GCreateCheckRunInput
  ];
  @override
  final String wireName = 'GCreateCheckRunInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateCheckRunInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'headSha',
      serializers.serialize(object.headSha,
          specifiedType: const FullType(String)),
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.actions;
    if (value != null) {
      result
        ..add('actions')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(
                BuiltList, const [const FullType(GCheckRunAction)])));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.completedAt;
    if (value != null) {
      result
        ..add('completedAt')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(DateTime)));
    }
    value = object.conclusion;
    if (value != null) {
      result
        ..add('conclusion')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GCheckConclusionState)));
    }
    value = object.detailsUrl;
    if (value != null) {
      result
        ..add('detailsUrl')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.externalId;
    if (value != null) {
      result
        ..add('externalId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.output;
    if (value != null) {
      result
        ..add('output')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GCheckRunOutput)));
    }
    value = object.startedAt;
    if (value != null) {
      result
        ..add('startedAt')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(DateTime)));
    }
    value = object.status;
    if (value != null) {
      result
        ..add('status')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GRequestableCheckStatusState)));
    }
    return result;
  }

  @override
  GCreateCheckRunInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateCheckRunInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'actions':
          result.actions.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(GCheckRunAction)]))!
              as BuiltList<Object>);
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'completedAt':
          result.completedAt = serializers.deserialize(value,
              specifiedType: const FullType(DateTime)) as DateTime;
          break;
        case 'conclusion':
          result.conclusion = serializers.deserialize(value,
                  specifiedType: const FullType(GCheckConclusionState))
              as GCheckConclusionState;
          break;
        case 'detailsUrl':
          result.detailsUrl = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'externalId':
          result.externalId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'headSha':
          result.headSha = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'output':
          result.output.replace(serializers.deserialize(value,
                  specifiedType: const FullType(GCheckRunOutput))!
              as GCheckRunOutput);
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'startedAt':
          result.startedAt = serializers.deserialize(value,
              specifiedType: const FullType(DateTime)) as DateTime;
          break;
        case 'status':
          result.status = serializers.deserialize(value,
                  specifiedType: const FullType(GRequestableCheckStatusState))
              as GRequestableCheckStatusState;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateCheckSuiteInputSerializer
    implements StructuredSerializer<GCreateCheckSuiteInput> {
  @override
  final Iterable<Type> types = const [
    GCreateCheckSuiteInput,
    _$GCreateCheckSuiteInput
  ];
  @override
  final String wireName = 'GCreateCheckSuiteInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateCheckSuiteInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'headSha',
      serializers.serialize(object.headSha,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCreateCheckSuiteInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateCheckSuiteInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'headSha':
          result.headSha = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateDiscussionInputSerializer
    implements StructuredSerializer<GCreateDiscussionInput> {
  @override
  final Iterable<Type> types = const [
    GCreateDiscussionInput,
    _$GCreateDiscussionInput
  ];
  @override
  final String wireName = 'GCreateDiscussionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateDiscussionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'categoryId',
      serializers.serialize(object.categoryId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
      'title',
      serializers.serialize(object.title,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCreateDiscussionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateDiscussionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'categoryId':
          result.categoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateEnterpriseOrganizationInputSerializer
    implements StructuredSerializer<GCreateEnterpriseOrganizationInput> {
  @override
  final Iterable<Type> types = const [
    GCreateEnterpriseOrganizationInput,
    _$GCreateEnterpriseOrganizationInput
  ];
  @override
  final String wireName = 'GCreateEnterpriseOrganizationInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateEnterpriseOrganizationInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'adminLogins',
      serializers.serialize(object.adminLogins,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'billingEmail',
      serializers.serialize(object.billingEmail,
          specifiedType: const FullType(String)),
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'login',
      serializers.serialize(object.login,
          specifiedType: const FullType(String)),
      'profileName',
      serializers.serialize(object.profileName,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCreateEnterpriseOrganizationInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateEnterpriseOrganizationInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'adminLogins':
          result.adminLogins.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'billingEmail':
          result.billingEmail = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'login':
          result.login = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'profileName':
          result.profileName = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateEnvironmentInputSerializer
    implements StructuredSerializer<GCreateEnvironmentInput> {
  @override
  final Iterable<Type> types = const [
    GCreateEnvironmentInput,
    _$GCreateEnvironmentInput
  ];
  @override
  final String wireName = 'GCreateEnvironmentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateEnvironmentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCreateEnvironmentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateEnvironmentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateIpAllowListEntryInputSerializer
    implements StructuredSerializer<GCreateIpAllowListEntryInput> {
  @override
  final Iterable<Type> types = const [
    GCreateIpAllowListEntryInput,
    _$GCreateIpAllowListEntryInput
  ];
  @override
  final String wireName = 'GCreateIpAllowListEntryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateIpAllowListEntryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'allowListValue',
      serializers.serialize(object.allowListValue,
          specifiedType: const FullType(String)),
      'isActive',
      serializers.serialize(object.isActive,
          specifiedType: const FullType(bool)),
      'ownerId',
      serializers.serialize(object.ownerId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.name;
    if (value != null) {
      result
        ..add('name')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCreateIpAllowListEntryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateIpAllowListEntryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'allowListValue':
          result.allowListValue = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'isActive':
          result.isActive = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ownerId':
          result.ownerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateIssueInputSerializer
    implements StructuredSerializer<GCreateIssueInput> {
  @override
  final Iterable<Type> types = const [GCreateIssueInput, _$GCreateIssueInput];
  @override
  final String wireName = 'GCreateIssueInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCreateIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
      'title',
      serializers.serialize(object.title,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.assigneeIds;
    if (value != null) {
      result
        ..add('assigneeIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.issueTemplate;
    if (value != null) {
      result
        ..add('issueTemplate')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.labelIds;
    if (value != null) {
      result
        ..add('labelIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.milestoneId;
    if (value != null) {
      result
        ..add('milestoneId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.projectIds;
    if (value != null) {
      result
        ..add('projectIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    return result;
  }

  @override
  GCreateIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'assigneeIds':
          result.assigneeIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issueTemplate':
          result.issueTemplate = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'labelIds':
          result.labelIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'milestoneId':
          result.milestoneId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectIds':
          result.projectIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateProjectInputSerializer
    implements StructuredSerializer<GCreateProjectInput> {
  @override
  final Iterable<Type> types = const [
    GCreateProjectInput,
    _$GCreateProjectInput
  ];
  @override
  final String wireName = 'GCreateProjectInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateProjectInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'ownerId',
      serializers.serialize(object.ownerId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.repositoryIds;
    if (value != null) {
      result
        ..add('repositoryIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.template;
    if (value != null) {
      result
        ..add('template')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GProjectTemplate)));
    }
    return result;
  }

  @override
  GCreateProjectInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateProjectInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ownerId':
          result.ownerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryIds':
          result.repositoryIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'template':
          result.template = serializers.deserialize(value,
                  specifiedType: const FullType(GProjectTemplate))
              as GProjectTemplate;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreatePullRequestInputSerializer
    implements StructuredSerializer<GCreatePullRequestInput> {
  @override
  final Iterable<Type> types = const [
    GCreatePullRequestInput,
    _$GCreatePullRequestInput
  ];
  @override
  final String wireName = 'GCreatePullRequestInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreatePullRequestInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'baseRefName',
      serializers.serialize(object.baseRefName,
          specifiedType: const FullType(String)),
      'headRefName',
      serializers.serialize(object.headRefName,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
      'title',
      serializers.serialize(object.title,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.draft;
    if (value != null) {
      result
        ..add('draft')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.maintainerCanModify;
    if (value != null) {
      result
        ..add('maintainerCanModify')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GCreatePullRequestInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreatePullRequestInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'baseRefName':
          result.baseRefName = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'draft':
          result.draft = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'headRefName':
          result.headRefName = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'maintainerCanModify':
          result.maintainerCanModify = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateRefInputSerializer
    implements StructuredSerializer<GCreateRefInput> {
  @override
  final Iterable<Type> types = const [GCreateRefInput, _$GCreateRefInput];
  @override
  final String wireName = 'GCreateRefInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GCreateRefInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'oid',
      serializers.serialize(object.oid, specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCreateRefInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateRefInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'oid':
          result.oid = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateRepositoryInputSerializer
    implements StructuredSerializer<GCreateRepositoryInput> {
  @override
  final Iterable<Type> types = const [
    GCreateRepositoryInput,
    _$GCreateRepositoryInput
  ];
  @override
  final String wireName = 'GCreateRepositoryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateRepositoryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'visibility',
      serializers.serialize(object.visibility,
          specifiedType: const FullType(GRepositoryVisibility)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.description;
    if (value != null) {
      result
        ..add('description')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.hasIssuesEnabled;
    if (value != null) {
      result
        ..add('hasIssuesEnabled')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.hasWikiEnabled;
    if (value != null) {
      result
        ..add('hasWikiEnabled')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.homepageUrl;
    if (value != null) {
      result
        ..add('homepageUrl')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.ownerId;
    if (value != null) {
      result
        ..add('ownerId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.teamId;
    if (value != null) {
      result
        ..add('teamId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.template;
    if (value != null) {
      result
        ..add('template')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GCreateRepositoryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateRepositoryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'description':
          result.description = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'hasIssuesEnabled':
          result.hasIssuesEnabled = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'hasWikiEnabled':
          result.hasWikiEnabled = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'homepageUrl':
          result.homepageUrl = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ownerId':
          result.ownerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'teamId':
          result.teamId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'template':
          result.template = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'visibility':
          result.visibility = serializers.deserialize(value,
                  specifiedType: const FullType(GRepositoryVisibility))
              as GRepositoryVisibility;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateTeamDiscussionCommentInputSerializer
    implements StructuredSerializer<GCreateTeamDiscussionCommentInput> {
  @override
  final Iterable<Type> types = const [
    GCreateTeamDiscussionCommentInput,
    _$GCreateTeamDiscussionCommentInput
  ];
  @override
  final String wireName = 'GCreateTeamDiscussionCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateTeamDiscussionCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'discussionId',
      serializers.serialize(object.discussionId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GCreateTeamDiscussionCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateTeamDiscussionCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'discussionId':
          result.discussionId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GCreateTeamDiscussionInputSerializer
    implements StructuredSerializer<GCreateTeamDiscussionInput> {
  @override
  final Iterable<Type> types = const [
    GCreateTeamDiscussionInput,
    _$GCreateTeamDiscussionInput
  ];
  @override
  final String wireName = 'GCreateTeamDiscussionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GCreateTeamDiscussionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'teamId',
      serializers.serialize(object.teamId,
          specifiedType: const FullType(String)),
      'title',
      serializers.serialize(object.title,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.private;
    if (value != null) {
      result
        ..add('private')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GCreateTeamDiscussionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GCreateTeamDiscussionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'private':
          result.private = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'teamId':
          result.teamId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeclineTopicSuggestionInputSerializer
    implements StructuredSerializer<GDeclineTopicSuggestionInput> {
  @override
  final Iterable<Type> types = const [
    GDeclineTopicSuggestionInput,
    _$GDeclineTopicSuggestionInput
  ];
  @override
  final String wireName = 'GDeclineTopicSuggestionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeclineTopicSuggestionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'reason',
      serializers.serialize(object.reason,
          specifiedType: const FullType(GTopicSuggestionDeclineReason)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeclineTopicSuggestionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeclineTopicSuggestionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'reason':
          result.reason = serializers.deserialize(value,
                  specifiedType: const FullType(GTopicSuggestionDeclineReason))
              as GTopicSuggestionDeclineReason;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDefaultRepositoryPermissionFieldSerializer
    implements PrimitiveSerializer<GDefaultRepositoryPermissionField> {
  @override
  final Iterable<Type> types = const <Type>[GDefaultRepositoryPermissionField];
  @override
  final String wireName = 'GDefaultRepositoryPermissionField';

  @override
  Object serialize(
          Serializers serializers, GDefaultRepositoryPermissionField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDefaultRepositoryPermissionField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDefaultRepositoryPermissionField.valueOf(serialized as String);
}

class _$GDeleteBranchProtectionRuleInputSerializer
    implements StructuredSerializer<GDeleteBranchProtectionRuleInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteBranchProtectionRuleInput,
    _$GDeleteBranchProtectionRuleInput
  ];
  @override
  final String wireName = 'GDeleteBranchProtectionRuleInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteBranchProtectionRuleInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'branchProtectionRuleId',
      serializers.serialize(object.branchProtectionRuleId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteBranchProtectionRuleInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteBranchProtectionRuleInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'branchProtectionRuleId':
          result.branchProtectionRuleId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteDeploymentInputSerializer
    implements StructuredSerializer<GDeleteDeploymentInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteDeploymentInput,
    _$GDeleteDeploymentInput
  ];
  @override
  final String wireName = 'GDeleteDeploymentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteDeploymentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteDeploymentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteDeploymentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteDiscussionCommentInputSerializer
    implements StructuredSerializer<GDeleteDiscussionCommentInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteDiscussionCommentInput,
    _$GDeleteDiscussionCommentInput
  ];
  @override
  final String wireName = 'GDeleteDiscussionCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteDiscussionCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteDiscussionCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteDiscussionCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteDiscussionInputSerializer
    implements StructuredSerializer<GDeleteDiscussionInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteDiscussionInput,
    _$GDeleteDiscussionInput
  ];
  @override
  final String wireName = 'GDeleteDiscussionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteDiscussionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteDiscussionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteDiscussionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteEnvironmentInputSerializer
    implements StructuredSerializer<GDeleteEnvironmentInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteEnvironmentInput,
    _$GDeleteEnvironmentInput
  ];
  @override
  final String wireName = 'GDeleteEnvironmentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteEnvironmentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteEnvironmentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteEnvironmentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteIpAllowListEntryInputSerializer
    implements StructuredSerializer<GDeleteIpAllowListEntryInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteIpAllowListEntryInput,
    _$GDeleteIpAllowListEntryInput
  ];
  @override
  final String wireName = 'GDeleteIpAllowListEntryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteIpAllowListEntryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'ipAllowListEntryId',
      serializers.serialize(object.ipAllowListEntryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteIpAllowListEntryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteIpAllowListEntryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ipAllowListEntryId':
          result.ipAllowListEntryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteIssueCommentInputSerializer
    implements StructuredSerializer<GDeleteIssueCommentInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteIssueCommentInput,
    _$GDeleteIssueCommentInput
  ];
  @override
  final String wireName = 'GDeleteIssueCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteIssueCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteIssueCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteIssueCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteIssueInputSerializer
    implements StructuredSerializer<GDeleteIssueInput> {
  @override
  final Iterable<Type> types = const [GDeleteIssueInput, _$GDeleteIssueInput];
  @override
  final String wireName = 'GDeleteIssueInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GDeleteIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'issueId',
      serializers.serialize(object.issueId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issueId':
          result.issueId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteProjectCardInputSerializer
    implements StructuredSerializer<GDeleteProjectCardInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteProjectCardInput,
    _$GDeleteProjectCardInput
  ];
  @override
  final String wireName = 'GDeleteProjectCardInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteProjectCardInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'cardId',
      serializers.serialize(object.cardId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteProjectCardInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteProjectCardInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'cardId':
          result.cardId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteProjectColumnInputSerializer
    implements StructuredSerializer<GDeleteProjectColumnInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteProjectColumnInput,
    _$GDeleteProjectColumnInput
  ];
  @override
  final String wireName = 'GDeleteProjectColumnInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteProjectColumnInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'columnId',
      serializers.serialize(object.columnId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteProjectColumnInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteProjectColumnInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'columnId':
          result.columnId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteProjectInputSerializer
    implements StructuredSerializer<GDeleteProjectInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteProjectInput,
    _$GDeleteProjectInput
  ];
  @override
  final String wireName = 'GDeleteProjectInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteProjectInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'projectId',
      serializers.serialize(object.projectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteProjectInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteProjectInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectId':
          result.projectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeletePullRequestReviewCommentInputSerializer
    implements StructuredSerializer<GDeletePullRequestReviewCommentInput> {
  @override
  final Iterable<Type> types = const [
    GDeletePullRequestReviewCommentInput,
    _$GDeletePullRequestReviewCommentInput
  ];
  @override
  final String wireName = 'GDeletePullRequestReviewCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeletePullRequestReviewCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeletePullRequestReviewCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeletePullRequestReviewCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeletePullRequestReviewInputSerializer
    implements StructuredSerializer<GDeletePullRequestReviewInput> {
  @override
  final Iterable<Type> types = const [
    GDeletePullRequestReviewInput,
    _$GDeletePullRequestReviewInput
  ];
  @override
  final String wireName = 'GDeletePullRequestReviewInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeletePullRequestReviewInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestReviewId',
      serializers.serialize(object.pullRequestReviewId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeletePullRequestReviewInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeletePullRequestReviewInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestReviewId':
          result.pullRequestReviewId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteRefInputSerializer
    implements StructuredSerializer<GDeleteRefInput> {
  @override
  final Iterable<Type> types = const [GDeleteRefInput, _$GDeleteRefInput];
  @override
  final String wireName = 'GDeleteRefInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GDeleteRefInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'refId',
      serializers.serialize(object.refId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteRefInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteRefInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'refId':
          result.refId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteTeamDiscussionCommentInputSerializer
    implements StructuredSerializer<GDeleteTeamDiscussionCommentInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteTeamDiscussionCommentInput,
    _$GDeleteTeamDiscussionCommentInput
  ];
  @override
  final String wireName = 'GDeleteTeamDiscussionCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteTeamDiscussionCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteTeamDiscussionCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteTeamDiscussionCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteTeamDiscussionInputSerializer
    implements StructuredSerializer<GDeleteTeamDiscussionInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteTeamDiscussionInput,
    _$GDeleteTeamDiscussionInput
  ];
  @override
  final String wireName = 'GDeleteTeamDiscussionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteTeamDiscussionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteTeamDiscussionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteTeamDiscussionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeleteVerifiableDomainInputSerializer
    implements StructuredSerializer<GDeleteVerifiableDomainInput> {
  @override
  final Iterable<Type> types = const [
    GDeleteVerifiableDomainInput,
    _$GDeleteVerifiableDomainInput
  ];
  @override
  final String wireName = 'GDeleteVerifiableDomainInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDeleteVerifiableDomainInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDeleteVerifiableDomainInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeleteVerifiableDomainInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeploymentOrderSerializer
    implements StructuredSerializer<GDeploymentOrder> {
  @override
  final Iterable<Type> types = const [GDeploymentOrder, _$GDeploymentOrder];
  @override
  final String wireName = 'GDeploymentOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GDeploymentOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GDeploymentOrderField)),
    ];

    return result;
  }

  @override
  GDeploymentOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDeploymentOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GDeploymentOrderField))
              as GDeploymentOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GDeploymentOrderFieldSerializer
    implements PrimitiveSerializer<GDeploymentOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GDeploymentOrderField];
  @override
  final String wireName = 'GDeploymentOrderField';

  @override
  Object serialize(Serializers serializers, GDeploymentOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDeploymentOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDeploymentOrderField.valueOf(serialized as String);
}

class _$GDeploymentProtectionRuleTypeSerializer
    implements PrimitiveSerializer<GDeploymentProtectionRuleType> {
  @override
  final Iterable<Type> types = const <Type>[GDeploymentProtectionRuleType];
  @override
  final String wireName = 'GDeploymentProtectionRuleType';

  @override
  Object serialize(
          Serializers serializers, GDeploymentProtectionRuleType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDeploymentProtectionRuleType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDeploymentProtectionRuleType.valueOf(serialized as String);
}

class _$GDeploymentReviewStateSerializer
    implements PrimitiveSerializer<GDeploymentReviewState> {
  @override
  final Iterable<Type> types = const <Type>[GDeploymentReviewState];
  @override
  final String wireName = 'GDeploymentReviewState';

  @override
  Object serialize(Serializers serializers, GDeploymentReviewState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDeploymentReviewState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDeploymentReviewState.valueOf(serialized as String);
}

class _$GDeploymentStateSerializer
    implements PrimitiveSerializer<GDeploymentState> {
  @override
  final Iterable<Type> types = const <Type>[GDeploymentState];
  @override
  final String wireName = 'GDeploymentState';

  @override
  Object serialize(Serializers serializers, GDeploymentState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDeploymentState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDeploymentState.valueOf(serialized as String);
}

class _$GDeploymentStatusStateSerializer
    implements PrimitiveSerializer<GDeploymentStatusState> {
  @override
  final Iterable<Type> types = const <Type>[GDeploymentStatusState];
  @override
  final String wireName = 'GDeploymentStatusState';

  @override
  Object serialize(Serializers serializers, GDeploymentStatusState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDeploymentStatusState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDeploymentStatusState.valueOf(serialized as String);
}

class _$GDiffSideSerializer implements PrimitiveSerializer<GDiffSide> {
  @override
  final Iterable<Type> types = const <Type>[GDiffSide];
  @override
  final String wireName = 'GDiffSide';

  @override
  Object serialize(Serializers serializers, GDiffSide object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDiffSide deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDiffSide.valueOf(serialized as String);
}

class _$GDisablePullRequestAutoMergeInputSerializer
    implements StructuredSerializer<GDisablePullRequestAutoMergeInput> {
  @override
  final Iterable<Type> types = const [
    GDisablePullRequestAutoMergeInput,
    _$GDisablePullRequestAutoMergeInput
  ];
  @override
  final String wireName = 'GDisablePullRequestAutoMergeInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDisablePullRequestAutoMergeInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDisablePullRequestAutoMergeInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDisablePullRequestAutoMergeInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDiscussionOrderSerializer
    implements StructuredSerializer<GDiscussionOrder> {
  @override
  final Iterable<Type> types = const [GDiscussionOrder, _$GDiscussionOrder];
  @override
  final String wireName = 'GDiscussionOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GDiscussionOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GDiscussionOrderField)),
    ];

    return result;
  }

  @override
  GDiscussionOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDiscussionOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GDiscussionOrderField))
              as GDiscussionOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GDiscussionOrderFieldSerializer
    implements PrimitiveSerializer<GDiscussionOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GDiscussionOrderField];
  @override
  final String wireName = 'GDiscussionOrderField';

  @override
  Object serialize(Serializers serializers, GDiscussionOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GDiscussionOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GDiscussionOrderField.valueOf(serialized as String);
}

class _$GDismissPullRequestReviewInputSerializer
    implements StructuredSerializer<GDismissPullRequestReviewInput> {
  @override
  final Iterable<Type> types = const [
    GDismissPullRequestReviewInput,
    _$GDismissPullRequestReviewInput
  ];
  @override
  final String wireName = 'GDismissPullRequestReviewInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDismissPullRequestReviewInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'message',
      serializers.serialize(object.message,
          specifiedType: const FullType(String)),
      'pullRequestReviewId',
      serializers.serialize(object.pullRequestReviewId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GDismissPullRequestReviewInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDismissPullRequestReviewInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'message':
          result.message = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestReviewId':
          result.pullRequestReviewId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GDraftPullRequestReviewCommentSerializer
    implements StructuredSerializer<GDraftPullRequestReviewComment> {
  @override
  final Iterable<Type> types = const [
    GDraftPullRequestReviewComment,
    _$GDraftPullRequestReviewComment
  ];
  @override
  final String wireName = 'GDraftPullRequestReviewComment';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDraftPullRequestReviewComment object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'path',
      serializers.serialize(object.path, specifiedType: const FullType(String)),
      'position',
      serializers.serialize(object.position,
          specifiedType: const FullType(int)),
    ];

    return result;
  }

  @override
  GDraftPullRequestReviewComment deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDraftPullRequestReviewCommentBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'path':
          result.path = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'position':
          result.position = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
      }
    }

    return result.build();
  }
}

class _$GDraftPullRequestReviewThreadSerializer
    implements StructuredSerializer<GDraftPullRequestReviewThread> {
  @override
  final Iterable<Type> types = const [
    GDraftPullRequestReviewThread,
    _$GDraftPullRequestReviewThread
  ];
  @override
  final String wireName = 'GDraftPullRequestReviewThread';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GDraftPullRequestReviewThread object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'line',
      serializers.serialize(object.line, specifiedType: const FullType(int)),
      'path',
      serializers.serialize(object.path, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.side;
    if (value != null) {
      result
        ..add('side')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GDiffSide)));
    }
    value = object.startLine;
    if (value != null) {
      result
        ..add('startLine')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.startSide;
    if (value != null) {
      result
        ..add('startSide')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GDiffSide)));
    }
    return result;
  }

  @override
  GDraftPullRequestReviewThread deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GDraftPullRequestReviewThreadBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'line':
          result.line = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'path':
          result.path = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'side':
          result.side = serializers.deserialize(value,
              specifiedType: const FullType(GDiffSide)) as GDiffSide;
          break;
        case 'startLine':
          result.startLine = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'startSide':
          result.startSide = serializers.deserialize(value,
              specifiedType: const FullType(GDiffSide)) as GDiffSide;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnablePullRequestAutoMergeInputSerializer
    implements StructuredSerializer<GEnablePullRequestAutoMergeInput> {
  @override
  final Iterable<Type> types = const [
    GEnablePullRequestAutoMergeInput,
    _$GEnablePullRequestAutoMergeInput
  ];
  @override
  final String wireName = 'GEnablePullRequestAutoMergeInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GEnablePullRequestAutoMergeInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.authorEmail;
    if (value != null) {
      result
        ..add('authorEmail')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.commitBody;
    if (value != null) {
      result
        ..add('commitBody')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.commitHeadline;
    if (value != null) {
      result
        ..add('commitHeadline')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.mergeMethod;
    if (value != null) {
      result
        ..add('mergeMethod')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GPullRequestMergeMethod)));
    }
    return result;
  }

  @override
  GEnablePullRequestAutoMergeInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GEnablePullRequestAutoMergeInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'authorEmail':
          result.authorEmail = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'commitBody':
          result.commitBody = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'commitHeadline':
          result.commitHeadline = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'mergeMethod':
          result.mergeMethod = serializers.deserialize(value,
                  specifiedType: const FullType(GPullRequestMergeMethod))
              as GPullRequestMergeMethod;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnterpriseAdministratorInvitationOrderSerializer
    implements StructuredSerializer<GEnterpriseAdministratorInvitationOrder> {
  @override
  final Iterable<Type> types = const [
    GEnterpriseAdministratorInvitationOrder,
    _$GEnterpriseAdministratorInvitationOrder
  ];
  @override
  final String wireName = 'GEnterpriseAdministratorInvitationOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GEnterpriseAdministratorInvitationOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType:
              const FullType(GEnterpriseAdministratorInvitationOrderField)),
    ];

    return result;
  }

  @override
  GEnterpriseAdministratorInvitationOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GEnterpriseAdministratorInvitationOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(
                      GEnterpriseAdministratorInvitationOrderField))
              as GEnterpriseAdministratorInvitationOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnterpriseAdministratorInvitationOrderFieldSerializer
    implements
        PrimitiveSerializer<GEnterpriseAdministratorInvitationOrderField> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseAdministratorInvitationOrderField
  ];
  @override
  final String wireName = 'GEnterpriseAdministratorInvitationOrderField';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseAdministratorInvitationOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseAdministratorInvitationOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseAdministratorInvitationOrderField.valueOf(
          serialized as String);
}

class _$GEnterpriseAdministratorRoleSerializer
    implements PrimitiveSerializer<GEnterpriseAdministratorRole> {
  @override
  final Iterable<Type> types = const <Type>[GEnterpriseAdministratorRole];
  @override
  final String wireName = 'GEnterpriseAdministratorRole';

  @override
  Object serialize(Serializers serializers, GEnterpriseAdministratorRole object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseAdministratorRole deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseAdministratorRole.valueOf(serialized as String);
}

class _$GEnterpriseDefaultRepositoryPermissionSettingValueSerializer
    implements
        PrimitiveSerializer<
            GEnterpriseDefaultRepositoryPermissionSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseDefaultRepositoryPermissionSettingValue
  ];
  @override
  final String wireName = 'GEnterpriseDefaultRepositoryPermissionSettingValue';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseDefaultRepositoryPermissionSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseDefaultRepositoryPermissionSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseDefaultRepositoryPermissionSettingValue.valueOf(
          serialized as String);
}

class _$GEnterpriseEnabledDisabledSettingValueSerializer
    implements PrimitiveSerializer<GEnterpriseEnabledDisabledSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseEnabledDisabledSettingValue
  ];
  @override
  final String wireName = 'GEnterpriseEnabledDisabledSettingValue';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseEnabledDisabledSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseEnabledDisabledSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseEnabledDisabledSettingValue.valueOf(serialized as String);
}

class _$GEnterpriseEnabledSettingValueSerializer
    implements PrimitiveSerializer<GEnterpriseEnabledSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[GEnterpriseEnabledSettingValue];
  @override
  final String wireName = 'GEnterpriseEnabledSettingValue';

  @override
  Object serialize(
          Serializers serializers, GEnterpriseEnabledSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseEnabledSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseEnabledSettingValue.valueOf(serialized as String);
}

class _$GEnterpriseMemberOrderSerializer
    implements StructuredSerializer<GEnterpriseMemberOrder> {
  @override
  final Iterable<Type> types = const [
    GEnterpriseMemberOrder,
    _$GEnterpriseMemberOrder
  ];
  @override
  final String wireName = 'GEnterpriseMemberOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GEnterpriseMemberOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GEnterpriseMemberOrderField)),
    ];

    return result;
  }

  @override
  GEnterpriseMemberOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GEnterpriseMemberOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GEnterpriseMemberOrderField))
              as GEnterpriseMemberOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnterpriseMemberOrderFieldSerializer
    implements PrimitiveSerializer<GEnterpriseMemberOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GEnterpriseMemberOrderField];
  @override
  final String wireName = 'GEnterpriseMemberOrderField';

  @override
  Object serialize(Serializers serializers, GEnterpriseMemberOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseMemberOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseMemberOrderField.valueOf(serialized as String);
}

class _$GEnterpriseMembersCanCreateRepositoriesSettingValueSerializer
    implements
        PrimitiveSerializer<
            GEnterpriseMembersCanCreateRepositoriesSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseMembersCanCreateRepositoriesSettingValue
  ];
  @override
  final String wireName = 'GEnterpriseMembersCanCreateRepositoriesSettingValue';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseMembersCanCreateRepositoriesSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseMembersCanCreateRepositoriesSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseMembersCanCreateRepositoriesSettingValue.valueOf(
          serialized as String);
}

class _$GEnterpriseMembersCanMakePurchasesSettingValueSerializer
    implements
        PrimitiveSerializer<GEnterpriseMembersCanMakePurchasesSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseMembersCanMakePurchasesSettingValue
  ];
  @override
  final String wireName = 'GEnterpriseMembersCanMakePurchasesSettingValue';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseMembersCanMakePurchasesSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseMembersCanMakePurchasesSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseMembersCanMakePurchasesSettingValue.valueOf(
          serialized as String);
}

class _$GEnterpriseServerInstallationOrderSerializer
    implements StructuredSerializer<GEnterpriseServerInstallationOrder> {
  @override
  final Iterable<Type> types = const [
    GEnterpriseServerInstallationOrder,
    _$GEnterpriseServerInstallationOrder
  ];
  @override
  final String wireName = 'GEnterpriseServerInstallationOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GEnterpriseServerInstallationOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType:
              const FullType(GEnterpriseServerInstallationOrderField)),
    ];

    return result;
  }

  @override
  GEnterpriseServerInstallationOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GEnterpriseServerInstallationOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseServerInstallationOrderField))
              as GEnterpriseServerInstallationOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnterpriseServerInstallationOrderFieldSerializer
    implements PrimitiveSerializer<GEnterpriseServerInstallationOrderField> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseServerInstallationOrderField
  ];
  @override
  final String wireName = 'GEnterpriseServerInstallationOrderField';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseServerInstallationOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseServerInstallationOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseServerInstallationOrderField.valueOf(serialized as String);
}

class _$GEnterpriseServerUserAccountEmailOrderSerializer
    implements StructuredSerializer<GEnterpriseServerUserAccountEmailOrder> {
  @override
  final Iterable<Type> types = const [
    GEnterpriseServerUserAccountEmailOrder,
    _$GEnterpriseServerUserAccountEmailOrder
  ];
  @override
  final String wireName = 'GEnterpriseServerUserAccountEmailOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GEnterpriseServerUserAccountEmailOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType:
              const FullType(GEnterpriseServerUserAccountEmailOrderField)),
    ];

    return result;
  }

  @override
  GEnterpriseServerUserAccountEmailOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GEnterpriseServerUserAccountEmailOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(
                      GEnterpriseServerUserAccountEmailOrderField))
              as GEnterpriseServerUserAccountEmailOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnterpriseServerUserAccountEmailOrderFieldSerializer
    implements
        PrimitiveSerializer<GEnterpriseServerUserAccountEmailOrderField> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseServerUserAccountEmailOrderField
  ];
  @override
  final String wireName = 'GEnterpriseServerUserAccountEmailOrderField';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseServerUserAccountEmailOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseServerUserAccountEmailOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseServerUserAccountEmailOrderField.valueOf(serialized as String);
}

class _$GEnterpriseServerUserAccountOrderSerializer
    implements StructuredSerializer<GEnterpriseServerUserAccountOrder> {
  @override
  final Iterable<Type> types = const [
    GEnterpriseServerUserAccountOrder,
    _$GEnterpriseServerUserAccountOrder
  ];
  @override
  final String wireName = 'GEnterpriseServerUserAccountOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GEnterpriseServerUserAccountOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType:
              const FullType(GEnterpriseServerUserAccountOrderField)),
    ];

    return result;
  }

  @override
  GEnterpriseServerUserAccountOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GEnterpriseServerUserAccountOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseServerUserAccountOrderField))
              as GEnterpriseServerUserAccountOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnterpriseServerUserAccountOrderFieldSerializer
    implements PrimitiveSerializer<GEnterpriseServerUserAccountOrderField> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseServerUserAccountOrderField
  ];
  @override
  final String wireName = 'GEnterpriseServerUserAccountOrderField';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseServerUserAccountOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseServerUserAccountOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseServerUserAccountOrderField.valueOf(serialized as String);
}

class _$GEnterpriseServerUserAccountsUploadOrderSerializer
    implements StructuredSerializer<GEnterpriseServerUserAccountsUploadOrder> {
  @override
  final Iterable<Type> types = const [
    GEnterpriseServerUserAccountsUploadOrder,
    _$GEnterpriseServerUserAccountsUploadOrder
  ];
  @override
  final String wireName = 'GEnterpriseServerUserAccountsUploadOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GEnterpriseServerUserAccountsUploadOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType:
              const FullType(GEnterpriseServerUserAccountsUploadOrderField)),
    ];

    return result;
  }

  @override
  GEnterpriseServerUserAccountsUploadOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GEnterpriseServerUserAccountsUploadOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(
                      GEnterpriseServerUserAccountsUploadOrderField))
              as GEnterpriseServerUserAccountsUploadOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GEnterpriseServerUserAccountsUploadOrderFieldSerializer
    implements
        PrimitiveSerializer<GEnterpriseServerUserAccountsUploadOrderField> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseServerUserAccountsUploadOrderField
  ];
  @override
  final String wireName = 'GEnterpriseServerUserAccountsUploadOrderField';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseServerUserAccountsUploadOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseServerUserAccountsUploadOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseServerUserAccountsUploadOrderField.valueOf(
          serialized as String);
}

class _$GEnterpriseServerUserAccountsUploadSyncStateSerializer
    implements
        PrimitiveSerializer<GEnterpriseServerUserAccountsUploadSyncState> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseServerUserAccountsUploadSyncState
  ];
  @override
  final String wireName = 'GEnterpriseServerUserAccountsUploadSyncState';

  @override
  Object serialize(Serializers serializers,
          GEnterpriseServerUserAccountsUploadSyncState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseServerUserAccountsUploadSyncState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseServerUserAccountsUploadSyncState.valueOf(
          serialized as String);
}

class _$GEnterpriseUserAccountMembershipRoleSerializer
    implements PrimitiveSerializer<GEnterpriseUserAccountMembershipRole> {
  @override
  final Iterable<Type> types = const <Type>[
    GEnterpriseUserAccountMembershipRole
  ];
  @override
  final String wireName = 'GEnterpriseUserAccountMembershipRole';

  @override
  Object serialize(
          Serializers serializers, GEnterpriseUserAccountMembershipRole object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseUserAccountMembershipRole deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseUserAccountMembershipRole.valueOf(serialized as String);
}

class _$GEnterpriseUserDeploymentSerializer
    implements PrimitiveSerializer<GEnterpriseUserDeployment> {
  @override
  final Iterable<Type> types = const <Type>[GEnterpriseUserDeployment];
  @override
  final String wireName = 'GEnterpriseUserDeployment';

  @override
  Object serialize(Serializers serializers, GEnterpriseUserDeployment object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GEnterpriseUserDeployment deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GEnterpriseUserDeployment.valueOf(serialized as String);
}

class _$GFileViewedStateSerializer
    implements PrimitiveSerializer<GFileViewedState> {
  @override
  final Iterable<Type> types = const <Type>[GFileViewedState];
  @override
  final String wireName = 'GFileViewedState';

  @override
  Object serialize(Serializers serializers, GFileViewedState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GFileViewedState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GFileViewedState.valueOf(serialized as String);
}

class _$GFollowUserInputSerializer
    implements StructuredSerializer<GFollowUserInput> {
  @override
  final Iterable<Type> types = const [GFollowUserInput, _$GFollowUserInput];
  @override
  final String wireName = 'GFollowUserInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GFollowUserInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'userId',
      serializers.serialize(object.userId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GFollowUserInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GFollowUserInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'userId':
          result.userId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GFundingPlatformSerializer
    implements PrimitiveSerializer<GFundingPlatform> {
  @override
  final Iterable<Type> types = const <Type>[GFundingPlatform];
  @override
  final String wireName = 'GFundingPlatform';

  @override
  Object serialize(Serializers serializers, GFundingPlatform object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GFundingPlatform deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GFundingPlatform.valueOf(serialized as String);
}

class _$GGistOrderSerializer implements StructuredSerializer<GGistOrder> {
  @override
  final Iterable<Type> types = const [GGistOrder, _$GGistOrder];
  @override
  final String wireName = 'GGistOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GGistOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GGistOrderField)),
    ];

    return result;
  }

  @override
  GGistOrder deserialize(Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GGistOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GGistOrderField))
              as GGistOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GGistOrderFieldSerializer
    implements PrimitiveSerializer<GGistOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GGistOrderField];
  @override
  final String wireName = 'GGistOrderField';

  @override
  Object serialize(Serializers serializers, GGistOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GGistOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GGistOrderField.valueOf(serialized as String);
}

class _$GGistPrivacySerializer implements PrimitiveSerializer<GGistPrivacy> {
  @override
  final Iterable<Type> types = const <Type>[GGistPrivacy];
  @override
  final String wireName = 'GGistPrivacy';

  @override
  Object serialize(Serializers serializers, GGistPrivacy object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GGistPrivacy deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GGistPrivacy.valueOf(serialized as String);
}

class _$GGitSignatureStateSerializer
    implements PrimitiveSerializer<GGitSignatureState> {
  @override
  final Iterable<Type> types = const <Type>[GGitSignatureState];
  @override
  final String wireName = 'GGitSignatureState';

  @override
  Object serialize(Serializers serializers, GGitSignatureState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GGitSignatureState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GGitSignatureState.valueOf(serialized as String);
}

class _$GIdentityProviderConfigurationStateSerializer
    implements PrimitiveSerializer<GIdentityProviderConfigurationState> {
  @override
  final Iterable<Type> types = const <Type>[
    GIdentityProviderConfigurationState
  ];
  @override
  final String wireName = 'GIdentityProviderConfigurationState';

  @override
  Object serialize(
          Serializers serializers, GIdentityProviderConfigurationState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GIdentityProviderConfigurationState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GIdentityProviderConfigurationState.valueOf(serialized as String);
}

class _$GInviteEnterpriseAdminInputSerializer
    implements StructuredSerializer<GInviteEnterpriseAdminInput> {
  @override
  final Iterable<Type> types = const [
    GInviteEnterpriseAdminInput,
    _$GInviteEnterpriseAdminInput
  ];
  @override
  final String wireName = 'GInviteEnterpriseAdminInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GInviteEnterpriseAdminInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.email;
    if (value != null) {
      result
        ..add('email')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.invitee;
    if (value != null) {
      result
        ..add('invitee')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.role;
    if (value != null) {
      result
        ..add('role')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GEnterpriseAdministratorRole)));
    }
    return result;
  }

  @override
  GInviteEnterpriseAdminInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GInviteEnterpriseAdminInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'email':
          result.email = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'invitee':
          result.invitee = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'role':
          result.role = serializers.deserialize(value,
                  specifiedType: const FullType(GEnterpriseAdministratorRole))
              as GEnterpriseAdministratorRole;
          break;
      }
    }

    return result.build();
  }
}

class _$GIpAllowListEnabledSettingValueSerializer
    implements PrimitiveSerializer<GIpAllowListEnabledSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[GIpAllowListEnabledSettingValue];
  @override
  final String wireName = 'GIpAllowListEnabledSettingValue';

  @override
  Object serialize(
          Serializers serializers, GIpAllowListEnabledSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GIpAllowListEnabledSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GIpAllowListEnabledSettingValue.valueOf(serialized as String);
}

class _$GIpAllowListEntryOrderSerializer
    implements StructuredSerializer<GIpAllowListEntryOrder> {
  @override
  final Iterable<Type> types = const [
    GIpAllowListEntryOrder,
    _$GIpAllowListEntryOrder
  ];
  @override
  final String wireName = 'GIpAllowListEntryOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GIpAllowListEntryOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GIpAllowListEntryOrderField)),
    ];

    return result;
  }

  @override
  GIpAllowListEntryOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GIpAllowListEntryOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GIpAllowListEntryOrderField))
              as GIpAllowListEntryOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GIpAllowListEntryOrderFieldSerializer
    implements PrimitiveSerializer<GIpAllowListEntryOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GIpAllowListEntryOrderField];
  @override
  final String wireName = 'GIpAllowListEntryOrderField';

  @override
  Object serialize(Serializers serializers, GIpAllowListEntryOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GIpAllowListEntryOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GIpAllowListEntryOrderField.valueOf(serialized as String);
}

class _$GIssueCommentOrderSerializer
    implements StructuredSerializer<GIssueCommentOrder> {
  @override
  final Iterable<Type> types = const [GIssueCommentOrder, _$GIssueCommentOrder];
  @override
  final String wireName = 'GIssueCommentOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GIssueCommentOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GIssueCommentOrderField)),
    ];

    return result;
  }

  @override
  GIssueCommentOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GIssueCommentOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GIssueCommentOrderField))
              as GIssueCommentOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GIssueCommentOrderFieldSerializer
    implements PrimitiveSerializer<GIssueCommentOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GIssueCommentOrderField];
  @override
  final String wireName = 'GIssueCommentOrderField';

  @override
  Object serialize(Serializers serializers, GIssueCommentOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GIssueCommentOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GIssueCommentOrderField.valueOf(serialized as String);
}

class _$GIssueFiltersSerializer implements StructuredSerializer<GIssueFilters> {
  @override
  final Iterable<Type> types = const [GIssueFilters, _$GIssueFilters];
  @override
  final String wireName = 'GIssueFilters';

  @override
  Iterable<Object?> serialize(Serializers serializers, GIssueFilters object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.assignee;
    if (value != null) {
      result
        ..add('assignee')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.createdBy;
    if (value != null) {
      result
        ..add('createdBy')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.labels;
    if (value != null) {
      result
        ..add('labels')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.mentioned;
    if (value != null) {
      result
        ..add('mentioned')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.milestone;
    if (value != null) {
      result
        ..add('milestone')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.since;
    if (value != null) {
      result
        ..add('since')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(DateTime)));
    }
    value = object.states;
    if (value != null) {
      result
        ..add('states')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(
                BuiltList, const [const FullType(GIssueState)])));
    }
    value = object.viewerSubscribed;
    if (value != null) {
      result
        ..add('viewerSubscribed')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GIssueFilters deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GIssueFiltersBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'assignee':
          result.assignee = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'createdBy':
          result.createdBy = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'labels':
          result.labels.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'mentioned':
          result.mentioned = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'milestone':
          result.milestone = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'since':
          result.since = serializers.deserialize(value,
              specifiedType: const FullType(DateTime)) as DateTime;
          break;
        case 'states':
          result.states.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(GIssueState)]))!
              as BuiltList<Object>);
          break;
        case 'viewerSubscribed':
          result.viewerSubscribed = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
      }
    }

    return result.build();
  }
}

class _$GIssueOrderSerializer implements StructuredSerializer<GIssueOrder> {
  @override
  final Iterable<Type> types = const [GIssueOrder, _$GIssueOrder];
  @override
  final String wireName = 'GIssueOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GIssueOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GIssueOrderField)),
    ];

    return result;
  }

  @override
  GIssueOrder deserialize(Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GIssueOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GIssueOrderField))
              as GIssueOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GIssueOrderFieldSerializer
    implements PrimitiveSerializer<GIssueOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GIssueOrderField];
  @override
  final String wireName = 'GIssueOrderField';

  @override
  Object serialize(Serializers serializers, GIssueOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GIssueOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GIssueOrderField.valueOf(serialized as String);
}

class _$GIssueStateSerializer implements PrimitiveSerializer<GIssueState> {
  @override
  final Iterable<Type> types = const <Type>[GIssueState];
  @override
  final String wireName = 'GIssueState';

  @override
  Object serialize(Serializers serializers, GIssueState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GIssueState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GIssueState.valueOf(serialized as String);
}

class _$GIssueTimelineItemsItemTypeSerializer
    implements PrimitiveSerializer<GIssueTimelineItemsItemType> {
  @override
  final Iterable<Type> types = const <Type>[GIssueTimelineItemsItemType];
  @override
  final String wireName = 'GIssueTimelineItemsItemType';

  @override
  Object serialize(Serializers serializers, GIssueTimelineItemsItemType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GIssueTimelineItemsItemType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GIssueTimelineItemsItemType.valueOf(serialized as String);
}

class _$GLabelOrderSerializer implements StructuredSerializer<GLabelOrder> {
  @override
  final Iterable<Type> types = const [GLabelOrder, _$GLabelOrder];
  @override
  final String wireName = 'GLabelOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GLabelOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GLabelOrderField)),
    ];

    return result;
  }

  @override
  GLabelOrder deserialize(Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GLabelOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GLabelOrderField))
              as GLabelOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GLabelOrderFieldSerializer
    implements PrimitiveSerializer<GLabelOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GLabelOrderField];
  @override
  final String wireName = 'GLabelOrderField';

  @override
  Object serialize(Serializers serializers, GLabelOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GLabelOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GLabelOrderField.valueOf(serialized as String);
}

class _$GLanguageOrderSerializer
    implements StructuredSerializer<GLanguageOrder> {
  @override
  final Iterable<Type> types = const [GLanguageOrder, _$GLanguageOrder];
  @override
  final String wireName = 'GLanguageOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GLanguageOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GLanguageOrderField)),
    ];

    return result;
  }

  @override
  GLanguageOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GLanguageOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GLanguageOrderField))
              as GLanguageOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GLanguageOrderFieldSerializer
    implements PrimitiveSerializer<GLanguageOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GLanguageOrderField];
  @override
  final String wireName = 'GLanguageOrderField';

  @override
  Object serialize(Serializers serializers, GLanguageOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GLanguageOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GLanguageOrderField.valueOf(serialized as String);
}

class _$GLinkRepositoryToProjectInputSerializer
    implements StructuredSerializer<GLinkRepositoryToProjectInput> {
  @override
  final Iterable<Type> types = const [
    GLinkRepositoryToProjectInput,
    _$GLinkRepositoryToProjectInput
  ];
  @override
  final String wireName = 'GLinkRepositoryToProjectInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GLinkRepositoryToProjectInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'projectId',
      serializers.serialize(object.projectId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GLinkRepositoryToProjectInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GLinkRepositoryToProjectInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectId':
          result.projectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GLockLockableInputSerializer
    implements StructuredSerializer<GLockLockableInput> {
  @override
  final Iterable<Type> types = const [GLockLockableInput, _$GLockLockableInput];
  @override
  final String wireName = 'GLockLockableInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GLockLockableInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'lockableId',
      serializers.serialize(object.lockableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.lockReason;
    if (value != null) {
      result
        ..add('lockReason')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GLockReason)));
    }
    return result;
  }

  @override
  GLockLockableInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GLockLockableInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'lockReason':
          result.lockReason = serializers.deserialize(value,
              specifiedType: const FullType(GLockReason)) as GLockReason;
          break;
        case 'lockableId':
          result.lockableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GLockReasonSerializer implements PrimitiveSerializer<GLockReason> {
  @override
  final Iterable<Type> types = const <Type>[GLockReason];
  @override
  final String wireName = 'GLockReason';

  @override
  Object serialize(Serializers serializers, GLockReason object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GLockReason deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GLockReason.valueOf(serialized as String);
}

class _$GMarkDiscussionCommentAsAnswerInputSerializer
    implements StructuredSerializer<GMarkDiscussionCommentAsAnswerInput> {
  @override
  final Iterable<Type> types = const [
    GMarkDiscussionCommentAsAnswerInput,
    _$GMarkDiscussionCommentAsAnswerInput
  ];
  @override
  final String wireName = 'GMarkDiscussionCommentAsAnswerInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GMarkDiscussionCommentAsAnswerInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GMarkDiscussionCommentAsAnswerInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMarkDiscussionCommentAsAnswerInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GMarkFileAsViewedInputSerializer
    implements StructuredSerializer<GMarkFileAsViewedInput> {
  @override
  final Iterable<Type> types = const [
    GMarkFileAsViewedInput,
    _$GMarkFileAsViewedInput
  ];
  @override
  final String wireName = 'GMarkFileAsViewedInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GMarkFileAsViewedInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'path',
      serializers.serialize(object.path, specifiedType: const FullType(String)),
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GMarkFileAsViewedInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMarkFileAsViewedInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'path':
          result.path = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GMarkPullRequestReadyForReviewInputSerializer
    implements StructuredSerializer<GMarkPullRequestReadyForReviewInput> {
  @override
  final Iterable<Type> types = const [
    GMarkPullRequestReadyForReviewInput,
    _$GMarkPullRequestReadyForReviewInput
  ];
  @override
  final String wireName = 'GMarkPullRequestReadyForReviewInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GMarkPullRequestReadyForReviewInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GMarkPullRequestReadyForReviewInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMarkPullRequestReadyForReviewInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GMergeBranchInputSerializer
    implements StructuredSerializer<GMergeBranchInput> {
  @override
  final Iterable<Type> types = const [GMergeBranchInput, _$GMergeBranchInput];
  @override
  final String wireName = 'GMergeBranchInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GMergeBranchInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'base',
      serializers.serialize(object.base, specifiedType: const FullType(String)),
      'head',
      serializers.serialize(object.head, specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.authorEmail;
    if (value != null) {
      result
        ..add('authorEmail')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.commitMessage;
    if (value != null) {
      result
        ..add('commitMessage')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GMergeBranchInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMergeBranchInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'authorEmail':
          result.authorEmail = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'base':
          result.base = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'commitMessage':
          result.commitMessage = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'head':
          result.head = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GMergePullRequestInputSerializer
    implements StructuredSerializer<GMergePullRequestInput> {
  @override
  final Iterable<Type> types = const [
    GMergePullRequestInput,
    _$GMergePullRequestInput
  ];
  @override
  final String wireName = 'GMergePullRequestInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GMergePullRequestInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.authorEmail;
    if (value != null) {
      result
        ..add('authorEmail')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.commitBody;
    if (value != null) {
      result
        ..add('commitBody')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.commitHeadline;
    if (value != null) {
      result
        ..add('commitHeadline')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.expectedHeadOid;
    if (value != null) {
      result
        ..add('expectedHeadOid')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.mergeMethod;
    if (value != null) {
      result
        ..add('mergeMethod')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GPullRequestMergeMethod)));
    }
    return result;
  }

  @override
  GMergePullRequestInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMergePullRequestInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'authorEmail':
          result.authorEmail = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'commitBody':
          result.commitBody = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'commitHeadline':
          result.commitHeadline = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'expectedHeadOid':
          result.expectedHeadOid = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'mergeMethod':
          result.mergeMethod = serializers.deserialize(value,
                  specifiedType: const FullType(GPullRequestMergeMethod))
              as GPullRequestMergeMethod;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GMergeableStateSerializer
    implements PrimitiveSerializer<GMergeableState> {
  @override
  final Iterable<Type> types = const <Type>[GMergeableState];
  @override
  final String wireName = 'GMergeableState';

  @override
  Object serialize(Serializers serializers, GMergeableState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GMergeableState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GMergeableState.valueOf(serialized as String);
}

class _$GMilestoneOrderSerializer
    implements StructuredSerializer<GMilestoneOrder> {
  @override
  final Iterable<Type> types = const [GMilestoneOrder, _$GMilestoneOrder];
  @override
  final String wireName = 'GMilestoneOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GMilestoneOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GMilestoneOrderField)),
    ];

    return result;
  }

  @override
  GMilestoneOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMilestoneOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GMilestoneOrderField))
              as GMilestoneOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GMilestoneOrderFieldSerializer
    implements PrimitiveSerializer<GMilestoneOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GMilestoneOrderField];
  @override
  final String wireName = 'GMilestoneOrderField';

  @override
  Object serialize(Serializers serializers, GMilestoneOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GMilestoneOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GMilestoneOrderField.valueOf(serialized as String);
}

class _$GMilestoneStateSerializer
    implements PrimitiveSerializer<GMilestoneState> {
  @override
  final Iterable<Type> types = const <Type>[GMilestoneState];
  @override
  final String wireName = 'GMilestoneState';

  @override
  Object serialize(Serializers serializers, GMilestoneState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GMilestoneState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GMilestoneState.valueOf(serialized as String);
}

class _$GMinimizeCommentInputSerializer
    implements StructuredSerializer<GMinimizeCommentInput> {
  @override
  final Iterable<Type> types = const [
    GMinimizeCommentInput,
    _$GMinimizeCommentInput
  ];
  @override
  final String wireName = 'GMinimizeCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GMinimizeCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'classifier',
      serializers.serialize(object.classifier,
          specifiedType: const FullType(GReportedContentClassifiers)),
      'subjectId',
      serializers.serialize(object.subjectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GMinimizeCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMinimizeCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'classifier':
          result.classifier = serializers.deserialize(value,
                  specifiedType: const FullType(GReportedContentClassifiers))
              as GReportedContentClassifiers;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'subjectId':
          result.subjectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GMoveProjectCardInputSerializer
    implements StructuredSerializer<GMoveProjectCardInput> {
  @override
  final Iterable<Type> types = const [
    GMoveProjectCardInput,
    _$GMoveProjectCardInput
  ];
  @override
  final String wireName = 'GMoveProjectCardInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GMoveProjectCardInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'cardId',
      serializers.serialize(object.cardId,
          specifiedType: const FullType(String)),
      'columnId',
      serializers.serialize(object.columnId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.afterCardId;
    if (value != null) {
      result
        ..add('afterCardId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GMoveProjectCardInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMoveProjectCardInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'afterCardId':
          result.afterCardId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'cardId':
          result.cardId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'columnId':
          result.columnId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GMoveProjectColumnInputSerializer
    implements StructuredSerializer<GMoveProjectColumnInput> {
  @override
  final Iterable<Type> types = const [
    GMoveProjectColumnInput,
    _$GMoveProjectColumnInput
  ];
  @override
  final String wireName = 'GMoveProjectColumnInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GMoveProjectColumnInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'columnId',
      serializers.serialize(object.columnId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.afterColumnId;
    if (value != null) {
      result
        ..add('afterColumnId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GMoveProjectColumnInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GMoveProjectColumnInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'afterColumnId':
          result.afterColumnId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'columnId':
          result.columnId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GNotificationRestrictionSettingValueSerializer
    implements PrimitiveSerializer<GNotificationRestrictionSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[
    GNotificationRestrictionSettingValue
  ];
  @override
  final String wireName = 'GNotificationRestrictionSettingValue';

  @override
  Object serialize(
          Serializers serializers, GNotificationRestrictionSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GNotificationRestrictionSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GNotificationRestrictionSettingValue.valueOf(serialized as String);
}

class _$GOauthApplicationCreateAuditEntryStateSerializer
    implements PrimitiveSerializer<GOauthApplicationCreateAuditEntryState> {
  @override
  final Iterable<Type> types = const <Type>[
    GOauthApplicationCreateAuditEntryState
  ];
  @override
  final String wireName = 'GOauthApplicationCreateAuditEntryState';

  @override
  Object serialize(Serializers serializers,
          GOauthApplicationCreateAuditEntryState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOauthApplicationCreateAuditEntryState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOauthApplicationCreateAuditEntryState.valueOf(serialized as String);
}

class _$GOperationTypeSerializer
    implements PrimitiveSerializer<GOperationType> {
  @override
  final Iterable<Type> types = const <Type>[GOperationType];
  @override
  final String wireName = 'GOperationType';

  @override
  Object serialize(Serializers serializers, GOperationType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOperationType deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOperationType.valueOf(serialized as String);
}

class _$GOrderDirectionSerializer
    implements PrimitiveSerializer<GOrderDirection> {
  @override
  final Iterable<Type> types = const <Type>[GOrderDirection];
  @override
  final String wireName = 'GOrderDirection';

  @override
  Object serialize(Serializers serializers, GOrderDirection object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrderDirection deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrderDirection.valueOf(serialized as String);
}

class _$GOrgAddMemberAuditEntryPermissionSerializer
    implements PrimitiveSerializer<GOrgAddMemberAuditEntryPermission> {
  @override
  final Iterable<Type> types = const <Type>[GOrgAddMemberAuditEntryPermission];
  @override
  final String wireName = 'GOrgAddMemberAuditEntryPermission';

  @override
  Object serialize(
          Serializers serializers, GOrgAddMemberAuditEntryPermission object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgAddMemberAuditEntryPermission deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgAddMemberAuditEntryPermission.valueOf(serialized as String);
}

class _$GOrgCreateAuditEntryBillingPlanSerializer
    implements PrimitiveSerializer<GOrgCreateAuditEntryBillingPlan> {
  @override
  final Iterable<Type> types = const <Type>[GOrgCreateAuditEntryBillingPlan];
  @override
  final String wireName = 'GOrgCreateAuditEntryBillingPlan';

  @override
  Object serialize(
          Serializers serializers, GOrgCreateAuditEntryBillingPlan object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgCreateAuditEntryBillingPlan deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgCreateAuditEntryBillingPlan.valueOf(serialized as String);
}

class _$GOrgRemoveBillingManagerAuditEntryReasonSerializer
    implements PrimitiveSerializer<GOrgRemoveBillingManagerAuditEntryReason> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrgRemoveBillingManagerAuditEntryReason
  ];
  @override
  final String wireName = 'GOrgRemoveBillingManagerAuditEntryReason';

  @override
  Object serialize(Serializers serializers,
          GOrgRemoveBillingManagerAuditEntryReason object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgRemoveBillingManagerAuditEntryReason deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgRemoveBillingManagerAuditEntryReason.valueOf(serialized as String);
}

class _$GOrgRemoveMemberAuditEntryMembershipTypeSerializer
    implements PrimitiveSerializer<GOrgRemoveMemberAuditEntryMembershipType> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrgRemoveMemberAuditEntryMembershipType
  ];
  @override
  final String wireName = 'GOrgRemoveMemberAuditEntryMembershipType';

  @override
  Object serialize(Serializers serializers,
          GOrgRemoveMemberAuditEntryMembershipType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgRemoveMemberAuditEntryMembershipType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgRemoveMemberAuditEntryMembershipType.valueOf(serialized as String);
}

class _$GOrgRemoveMemberAuditEntryReasonSerializer
    implements PrimitiveSerializer<GOrgRemoveMemberAuditEntryReason> {
  @override
  final Iterable<Type> types = const <Type>[GOrgRemoveMemberAuditEntryReason];
  @override
  final String wireName = 'GOrgRemoveMemberAuditEntryReason';

  @override
  Object serialize(
          Serializers serializers, GOrgRemoveMemberAuditEntryReason object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgRemoveMemberAuditEntryReason deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgRemoveMemberAuditEntryReason.valueOf(serialized as String);
}

class _$GOrgRemoveOutsideCollaboratorAuditEntryMembershipTypeSerializer
    implements
        PrimitiveSerializer<
            GOrgRemoveOutsideCollaboratorAuditEntryMembershipType> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrgRemoveOutsideCollaboratorAuditEntryMembershipType
  ];
  @override
  final String wireName =
      'GOrgRemoveOutsideCollaboratorAuditEntryMembershipType';

  @override
  Object serialize(Serializers serializers,
          GOrgRemoveOutsideCollaboratorAuditEntryMembershipType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgRemoveOutsideCollaboratorAuditEntryMembershipType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgRemoveOutsideCollaboratorAuditEntryMembershipType.valueOf(
          serialized as String);
}

class _$GOrgRemoveOutsideCollaboratorAuditEntryReasonSerializer
    implements
        PrimitiveSerializer<GOrgRemoveOutsideCollaboratorAuditEntryReason> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrgRemoveOutsideCollaboratorAuditEntryReason
  ];
  @override
  final String wireName = 'GOrgRemoveOutsideCollaboratorAuditEntryReason';

  @override
  Object serialize(Serializers serializers,
          GOrgRemoveOutsideCollaboratorAuditEntryReason object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgRemoveOutsideCollaboratorAuditEntryReason deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgRemoveOutsideCollaboratorAuditEntryReason.valueOf(
          serialized as String);
}

class _$GOrgUpdateDefaultRepositoryPermissionAuditEntryPermissionSerializer
    implements
        PrimitiveSerializer<
            GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission
  ];
  @override
  final String wireName =
      'GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission';

  @override
  Object serialize(Serializers serializers,
          GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgUpdateDefaultRepositoryPermissionAuditEntryPermission.valueOf(
          serialized as String);
}

class _$GOrgUpdateMemberAuditEntryPermissionSerializer
    implements PrimitiveSerializer<GOrgUpdateMemberAuditEntryPermission> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrgUpdateMemberAuditEntryPermission
  ];
  @override
  final String wireName = 'GOrgUpdateMemberAuditEntryPermission';

  @override
  Object serialize(
          Serializers serializers, GOrgUpdateMemberAuditEntryPermission object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgUpdateMemberAuditEntryPermission deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgUpdateMemberAuditEntryPermission.valueOf(serialized as String);
}

class _$GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibilitySerializer
    implements
        PrimitiveSerializer<
            GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
  ];
  @override
  final String wireName =
      'GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility';

  @override
  Object serialize(
          Serializers serializers,
          GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility
              object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility.valueOf(
          serialized as String);
}

class _$GOrganizationInvitationRoleSerializer
    implements PrimitiveSerializer<GOrganizationInvitationRole> {
  @override
  final Iterable<Type> types = const <Type>[GOrganizationInvitationRole];
  @override
  final String wireName = 'GOrganizationInvitationRole';

  @override
  Object serialize(Serializers serializers, GOrganizationInvitationRole object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrganizationInvitationRole deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrganizationInvitationRole.valueOf(serialized as String);
}

class _$GOrganizationInvitationTypeSerializer
    implements PrimitiveSerializer<GOrganizationInvitationType> {
  @override
  final Iterable<Type> types = const <Type>[GOrganizationInvitationType];
  @override
  final String wireName = 'GOrganizationInvitationType';

  @override
  Object serialize(Serializers serializers, GOrganizationInvitationType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrganizationInvitationType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrganizationInvitationType.valueOf(serialized as String);
}

class _$GOrganizationMemberRoleSerializer
    implements PrimitiveSerializer<GOrganizationMemberRole> {
  @override
  final Iterable<Type> types = const <Type>[GOrganizationMemberRole];
  @override
  final String wireName = 'GOrganizationMemberRole';

  @override
  Object serialize(Serializers serializers, GOrganizationMemberRole object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrganizationMemberRole deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrganizationMemberRole.valueOf(serialized as String);
}

class _$GOrganizationMembersCanCreateRepositoriesSettingValueSerializer
    implements
        PrimitiveSerializer<
            GOrganizationMembersCanCreateRepositoriesSettingValue> {
  @override
  final Iterable<Type> types = const <Type>[
    GOrganizationMembersCanCreateRepositoriesSettingValue
  ];
  @override
  final String wireName =
      'GOrganizationMembersCanCreateRepositoriesSettingValue';

  @override
  Object serialize(Serializers serializers,
          GOrganizationMembersCanCreateRepositoriesSettingValue object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrganizationMembersCanCreateRepositoriesSettingValue deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrganizationMembersCanCreateRepositoriesSettingValue.valueOf(
          serialized as String);
}

class _$GOrganizationOrderSerializer
    implements StructuredSerializer<GOrganizationOrder> {
  @override
  final Iterable<Type> types = const [GOrganizationOrder, _$GOrganizationOrder];
  @override
  final String wireName = 'GOrganizationOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GOrganizationOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GOrganizationOrderField)),
    ];

    return result;
  }

  @override
  GOrganizationOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GOrganizationOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GOrganizationOrderField))
              as GOrganizationOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GOrganizationOrderFieldSerializer
    implements PrimitiveSerializer<GOrganizationOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GOrganizationOrderField];
  @override
  final String wireName = 'GOrganizationOrderField';

  @override
  Object serialize(Serializers serializers, GOrganizationOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GOrganizationOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GOrganizationOrderField.valueOf(serialized as String);
}

class _$GPackageFileOrderSerializer
    implements StructuredSerializer<GPackageFileOrder> {
  @override
  final Iterable<Type> types = const [GPackageFileOrder, _$GPackageFileOrder];
  @override
  final String wireName = 'GPackageFileOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GPackageFileOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.direction;
    if (value != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GOrderDirection)));
    }
    value = object.field;
    if (value != null) {
      result
        ..add('field')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GPackageFileOrderField)));
    }
    return result;
  }

  @override
  GPackageFileOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GPackageFileOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GPackageFileOrderField))
              as GPackageFileOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GPackageFileOrderFieldSerializer
    implements PrimitiveSerializer<GPackageFileOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GPackageFileOrderField];
  @override
  final String wireName = 'GPackageFileOrderField';

  @override
  Object serialize(Serializers serializers, GPackageFileOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPackageFileOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPackageFileOrderField.valueOf(serialized as String);
}

class _$GPackageOrderSerializer implements StructuredSerializer<GPackageOrder> {
  @override
  final Iterable<Type> types = const [GPackageOrder, _$GPackageOrder];
  @override
  final String wireName = 'GPackageOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GPackageOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.direction;
    if (value != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GOrderDirection)));
    }
    value = object.field;
    if (value != null) {
      result
        ..add('field')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GPackageOrderField)));
    }
    return result;
  }

  @override
  GPackageOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GPackageOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GPackageOrderField))
              as GPackageOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GPackageOrderFieldSerializer
    implements PrimitiveSerializer<GPackageOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GPackageOrderField];
  @override
  final String wireName = 'GPackageOrderField';

  @override
  Object serialize(Serializers serializers, GPackageOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPackageOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPackageOrderField.valueOf(serialized as String);
}

class _$GPackageTypeSerializer implements PrimitiveSerializer<GPackageType> {
  @override
  final Iterable<Type> types = const <Type>[GPackageType];
  @override
  final String wireName = 'GPackageType';

  @override
  Object serialize(Serializers serializers, GPackageType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPackageType deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPackageType.valueOf(serialized as String);
}

class _$GPackageVersionOrderSerializer
    implements StructuredSerializer<GPackageVersionOrder> {
  @override
  final Iterable<Type> types = const [
    GPackageVersionOrder,
    _$GPackageVersionOrder
  ];
  @override
  final String wireName = 'GPackageVersionOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GPackageVersionOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[];
    Object? value;
    value = object.direction;
    if (value != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GOrderDirection)));
    }
    value = object.field;
    if (value != null) {
      result
        ..add('field')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GPackageVersionOrderField)));
    }
    return result;
  }

  @override
  GPackageVersionOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GPackageVersionOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GPackageVersionOrderField))
              as GPackageVersionOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GPackageVersionOrderFieldSerializer
    implements PrimitiveSerializer<GPackageVersionOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GPackageVersionOrderField];
  @override
  final String wireName = 'GPackageVersionOrderField';

  @override
  Object serialize(Serializers serializers, GPackageVersionOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPackageVersionOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPackageVersionOrderField.valueOf(serialized as String);
}

class _$GPinIssueInputSerializer
    implements StructuredSerializer<GPinIssueInput> {
  @override
  final Iterable<Type> types = const [GPinIssueInput, _$GPinIssueInput];
  @override
  final String wireName = 'GPinIssueInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GPinIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'issueId',
      serializers.serialize(object.issueId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GPinIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GPinIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issueId':
          result.issueId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GPinnableItemTypeSerializer
    implements PrimitiveSerializer<GPinnableItemType> {
  @override
  final Iterable<Type> types = const <Type>[GPinnableItemType];
  @override
  final String wireName = 'GPinnableItemType';

  @override
  Object serialize(Serializers serializers, GPinnableItemType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPinnableItemType deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPinnableItemType.valueOf(serialized as String);
}

class _$GPinnedDiscussionGradientSerializer
    implements PrimitiveSerializer<GPinnedDiscussionGradient> {
  @override
  final Iterable<Type> types = const <Type>[GPinnedDiscussionGradient];
  @override
  final String wireName = 'GPinnedDiscussionGradient';

  @override
  Object serialize(Serializers serializers, GPinnedDiscussionGradient object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPinnedDiscussionGradient deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPinnedDiscussionGradient.valueOf(serialized as String);
}

class _$GPinnedDiscussionPatternSerializer
    implements PrimitiveSerializer<GPinnedDiscussionPattern> {
  @override
  final Iterable<Type> types = const <Type>[GPinnedDiscussionPattern];
  @override
  final String wireName = 'GPinnedDiscussionPattern';

  @override
  Object serialize(Serializers serializers, GPinnedDiscussionPattern object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPinnedDiscussionPattern deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPinnedDiscussionPattern.valueOf(serialized as String);
}

class _$GProjectCardArchivedStateSerializer
    implements PrimitiveSerializer<GProjectCardArchivedState> {
  @override
  final Iterable<Type> types = const <Type>[GProjectCardArchivedState];
  @override
  final String wireName = 'GProjectCardArchivedState';

  @override
  Object serialize(Serializers serializers, GProjectCardArchivedState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GProjectCardArchivedState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GProjectCardArchivedState.valueOf(serialized as String);
}

class _$GProjectCardStateSerializer
    implements PrimitiveSerializer<GProjectCardState> {
  @override
  final Iterable<Type> types = const <Type>[GProjectCardState];
  @override
  final String wireName = 'GProjectCardState';

  @override
  Object serialize(Serializers serializers, GProjectCardState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GProjectCardState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GProjectCardState.valueOf(serialized as String);
}

class _$GProjectColumnPurposeSerializer
    implements PrimitiveSerializer<GProjectColumnPurpose> {
  @override
  final Iterable<Type> types = const <Type>[GProjectColumnPurpose];
  @override
  final String wireName = 'GProjectColumnPurpose';

  @override
  Object serialize(Serializers serializers, GProjectColumnPurpose object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GProjectColumnPurpose deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GProjectColumnPurpose.valueOf(serialized as String);
}

class _$GProjectOrderSerializer implements StructuredSerializer<GProjectOrder> {
  @override
  final Iterable<Type> types = const [GProjectOrder, _$GProjectOrder];
  @override
  final String wireName = 'GProjectOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GProjectOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GProjectOrderField)),
    ];

    return result;
  }

  @override
  GProjectOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GProjectOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GProjectOrderField))
              as GProjectOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GProjectOrderFieldSerializer
    implements PrimitiveSerializer<GProjectOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GProjectOrderField];
  @override
  final String wireName = 'GProjectOrderField';

  @override
  Object serialize(Serializers serializers, GProjectOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GProjectOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GProjectOrderField.valueOf(serialized as String);
}

class _$GProjectStateSerializer implements PrimitiveSerializer<GProjectState> {
  @override
  final Iterable<Type> types = const <Type>[GProjectState];
  @override
  final String wireName = 'GProjectState';

  @override
  Object serialize(Serializers serializers, GProjectState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GProjectState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GProjectState.valueOf(serialized as String);
}

class _$GProjectTemplateSerializer
    implements PrimitiveSerializer<GProjectTemplate> {
  @override
  final Iterable<Type> types = const <Type>[GProjectTemplate];
  @override
  final String wireName = 'GProjectTemplate';

  @override
  Object serialize(Serializers serializers, GProjectTemplate object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GProjectTemplate deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GProjectTemplate.valueOf(serialized as String);
}

class _$GPullRequestMergeMethodSerializer
    implements PrimitiveSerializer<GPullRequestMergeMethod> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestMergeMethod];
  @override
  final String wireName = 'GPullRequestMergeMethod';

  @override
  Object serialize(Serializers serializers, GPullRequestMergeMethod object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestMergeMethod deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestMergeMethod.valueOf(serialized as String);
}

class _$GPullRequestOrderSerializer
    implements StructuredSerializer<GPullRequestOrder> {
  @override
  final Iterable<Type> types = const [GPullRequestOrder, _$GPullRequestOrder];
  @override
  final String wireName = 'GPullRequestOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GPullRequestOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GPullRequestOrderField)),
    ];

    return result;
  }

  @override
  GPullRequestOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GPullRequestOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GPullRequestOrderField))
              as GPullRequestOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GPullRequestOrderFieldSerializer
    implements PrimitiveSerializer<GPullRequestOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestOrderField];
  @override
  final String wireName = 'GPullRequestOrderField';

  @override
  Object serialize(Serializers serializers, GPullRequestOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestOrderField.valueOf(serialized as String);
}

class _$GPullRequestReviewCommentStateSerializer
    implements PrimitiveSerializer<GPullRequestReviewCommentState> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestReviewCommentState];
  @override
  final String wireName = 'GPullRequestReviewCommentState';

  @override
  Object serialize(
          Serializers serializers, GPullRequestReviewCommentState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestReviewCommentState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestReviewCommentState.valueOf(serialized as String);
}

class _$GPullRequestReviewDecisionSerializer
    implements PrimitiveSerializer<GPullRequestReviewDecision> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestReviewDecision];
  @override
  final String wireName = 'GPullRequestReviewDecision';

  @override
  Object serialize(Serializers serializers, GPullRequestReviewDecision object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestReviewDecision deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestReviewDecision.valueOf(serialized as String);
}

class _$GPullRequestReviewEventSerializer
    implements PrimitiveSerializer<GPullRequestReviewEvent> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestReviewEvent];
  @override
  final String wireName = 'GPullRequestReviewEvent';

  @override
  Object serialize(Serializers serializers, GPullRequestReviewEvent object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestReviewEvent deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestReviewEvent.valueOf(serialized as String);
}

class _$GPullRequestReviewStateSerializer
    implements PrimitiveSerializer<GPullRequestReviewState> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestReviewState];
  @override
  final String wireName = 'GPullRequestReviewState';

  @override
  Object serialize(Serializers serializers, GPullRequestReviewState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestReviewState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestReviewState.valueOf(serialized as String);
}

class _$GPullRequestStateSerializer
    implements PrimitiveSerializer<GPullRequestState> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestState];
  @override
  final String wireName = 'GPullRequestState';

  @override
  Object serialize(Serializers serializers, GPullRequestState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestState.valueOf(serialized as String);
}

class _$GPullRequestTimelineItemsItemTypeSerializer
    implements PrimitiveSerializer<GPullRequestTimelineItemsItemType> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestTimelineItemsItemType];
  @override
  final String wireName = 'GPullRequestTimelineItemsItemType';

  @override
  Object serialize(
          Serializers serializers, GPullRequestTimelineItemsItemType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestTimelineItemsItemType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestTimelineItemsItemType.valueOf(serialized as String);
}

class _$GPullRequestUpdateStateSerializer
    implements PrimitiveSerializer<GPullRequestUpdateState> {
  @override
  final Iterable<Type> types = const <Type>[GPullRequestUpdateState];
  @override
  final String wireName = 'GPullRequestUpdateState';

  @override
  Object serialize(Serializers serializers, GPullRequestUpdateState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GPullRequestUpdateState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GPullRequestUpdateState.valueOf(serialized as String);
}

class _$GReactionContentSerializer
    implements PrimitiveSerializer<GReactionContent> {
  @override
  final Iterable<Type> types = const <Type>[GReactionContent];
  @override
  final String wireName = 'GReactionContent';

  @override
  Object serialize(Serializers serializers, GReactionContent object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GReactionContent deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GReactionContent.valueOf(serialized as String);
}

class _$GReactionOrderSerializer
    implements StructuredSerializer<GReactionOrder> {
  @override
  final Iterable<Type> types = const [GReactionOrder, _$GReactionOrder];
  @override
  final String wireName = 'GReactionOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GReactionOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GReactionOrderField)),
    ];

    return result;
  }

  @override
  GReactionOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GReactionOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GReactionOrderField))
              as GReactionOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GReactionOrderFieldSerializer
    implements PrimitiveSerializer<GReactionOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GReactionOrderField];
  @override
  final String wireName = 'GReactionOrderField';

  @override
  Object serialize(Serializers serializers, GReactionOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GReactionOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GReactionOrderField.valueOf(serialized as String);
}

class _$GRefOrderSerializer implements StructuredSerializer<GRefOrder> {
  @override
  final Iterable<Type> types = const [GRefOrder, _$GRefOrder];
  @override
  final String wireName = 'GRefOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GRefOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GRefOrderField)),
    ];

    return result;
  }

  @override
  GRefOrder deserialize(Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRefOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
              specifiedType: const FullType(GRefOrderField)) as GRefOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GRefOrderFieldSerializer
    implements PrimitiveSerializer<GRefOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GRefOrderField];
  @override
  final String wireName = 'GRefOrderField';

  @override
  Object serialize(Serializers serializers, GRefOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRefOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRefOrderField.valueOf(serialized as String);
}

class _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInputSerializer
    implements
        StructuredSerializer<
            GRegenerateEnterpriseIdentityProviderRecoveryCodesInput> {
  @override
  final Iterable<Type> types = const [
    GRegenerateEnterpriseIdentityProviderRecoveryCodesInput,
    _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput
  ];
  @override
  final String wireName =
      'GRegenerateEnterpriseIdentityProviderRecoveryCodesInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GRegenerateEnterpriseIdentityProviderRecoveryCodesInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRegenerateEnterpriseIdentityProviderRecoveryCodesInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRegenerateVerifiableDomainTokenInputSerializer
    implements StructuredSerializer<GRegenerateVerifiableDomainTokenInput> {
  @override
  final Iterable<Type> types = const [
    GRegenerateVerifiableDomainTokenInput,
    _$GRegenerateVerifiableDomainTokenInput
  ];
  @override
  final String wireName = 'GRegenerateVerifiableDomainTokenInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRegenerateVerifiableDomainTokenInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRegenerateVerifiableDomainTokenInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRegenerateVerifiableDomainTokenInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRejectDeploymentsInputSerializer
    implements StructuredSerializer<GRejectDeploymentsInput> {
  @override
  final Iterable<Type> types = const [
    GRejectDeploymentsInput,
    _$GRejectDeploymentsInput
  ];
  @override
  final String wireName = 'GRejectDeploymentsInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRejectDeploymentsInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'environmentIds',
      serializers.serialize(object.environmentIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'workflowRunId',
      serializers.serialize(object.workflowRunId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.comment;
    if (value != null) {
      result
        ..add('comment')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRejectDeploymentsInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRejectDeploymentsInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'comment':
          result.comment = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'environmentIds':
          result.environmentIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'workflowRunId':
          result.workflowRunId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GReleaseOrderSerializer implements StructuredSerializer<GReleaseOrder> {
  @override
  final Iterable<Type> types = const [GReleaseOrder, _$GReleaseOrder];
  @override
  final String wireName = 'GReleaseOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GReleaseOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GReleaseOrderField)),
    ];

    return result;
  }

  @override
  GReleaseOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GReleaseOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GReleaseOrderField))
              as GReleaseOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GReleaseOrderFieldSerializer
    implements PrimitiveSerializer<GReleaseOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GReleaseOrderField];
  @override
  final String wireName = 'GReleaseOrderField';

  @override
  Object serialize(Serializers serializers, GReleaseOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GReleaseOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GReleaseOrderField.valueOf(serialized as String);
}

class _$GRemoveAssigneesFromAssignableInputSerializer
    implements StructuredSerializer<GRemoveAssigneesFromAssignableInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveAssigneesFromAssignableInput,
    _$GRemoveAssigneesFromAssignableInput
  ];
  @override
  final String wireName = 'GRemoveAssigneesFromAssignableInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveAssigneesFromAssignableInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'assignableId',
      serializers.serialize(object.assignableId,
          specifiedType: const FullType(String)),
      'assigneeIds',
      serializers.serialize(object.assigneeIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveAssigneesFromAssignableInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveAssigneesFromAssignableInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'assignableId':
          result.assignableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'assigneeIds':
          result.assigneeIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveEnterpriseAdminInputSerializer
    implements StructuredSerializer<GRemoveEnterpriseAdminInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveEnterpriseAdminInput,
    _$GRemoveEnterpriseAdminInput
  ];
  @override
  final String wireName = 'GRemoveEnterpriseAdminInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveEnterpriseAdminInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'login',
      serializers.serialize(object.login,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveEnterpriseAdminInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveEnterpriseAdminInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'login':
          result.login = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveEnterpriseIdentityProviderInputSerializer
    implements StructuredSerializer<GRemoveEnterpriseIdentityProviderInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveEnterpriseIdentityProviderInput,
    _$GRemoveEnterpriseIdentityProviderInput
  ];
  @override
  final String wireName = 'GRemoveEnterpriseIdentityProviderInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveEnterpriseIdentityProviderInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveEnterpriseIdentityProviderInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveEnterpriseIdentityProviderInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveEnterpriseOrganizationInputSerializer
    implements StructuredSerializer<GRemoveEnterpriseOrganizationInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveEnterpriseOrganizationInput,
    _$GRemoveEnterpriseOrganizationInput
  ];
  @override
  final String wireName = 'GRemoveEnterpriseOrganizationInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveEnterpriseOrganizationInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'organizationId',
      serializers.serialize(object.organizationId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveEnterpriseOrganizationInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveEnterpriseOrganizationInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'organizationId':
          result.organizationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveEnterpriseSupportEntitlementInputSerializer
    implements StructuredSerializer<GRemoveEnterpriseSupportEntitlementInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveEnterpriseSupportEntitlementInput,
    _$GRemoveEnterpriseSupportEntitlementInput
  ];
  @override
  final String wireName = 'GRemoveEnterpriseSupportEntitlementInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveEnterpriseSupportEntitlementInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'login',
      serializers.serialize(object.login,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveEnterpriseSupportEntitlementInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveEnterpriseSupportEntitlementInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'login':
          result.login = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveLabelsFromLabelableInputSerializer
    implements StructuredSerializer<GRemoveLabelsFromLabelableInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveLabelsFromLabelableInput,
    _$GRemoveLabelsFromLabelableInput
  ];
  @override
  final String wireName = 'GRemoveLabelsFromLabelableInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveLabelsFromLabelableInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'labelIds',
      serializers.serialize(object.labelIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'labelableId',
      serializers.serialize(object.labelableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveLabelsFromLabelableInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveLabelsFromLabelableInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'labelIds':
          result.labelIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'labelableId':
          result.labelableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveOutsideCollaboratorInputSerializer
    implements StructuredSerializer<GRemoveOutsideCollaboratorInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveOutsideCollaboratorInput,
    _$GRemoveOutsideCollaboratorInput
  ];
  @override
  final String wireName = 'GRemoveOutsideCollaboratorInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveOutsideCollaboratorInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'organizationId',
      serializers.serialize(object.organizationId,
          specifiedType: const FullType(String)),
      'userId',
      serializers.serialize(object.userId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveOutsideCollaboratorInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveOutsideCollaboratorInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'organizationId':
          result.organizationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'userId':
          result.userId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveReactionInputSerializer
    implements StructuredSerializer<GRemoveReactionInput> {
  @override
  final Iterable<Type> types = const [
    GRemoveReactionInput,
    _$GRemoveReactionInput
  ];
  @override
  final String wireName = 'GRemoveReactionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveReactionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'content',
      serializers.serialize(object.content,
          specifiedType: const FullType(GReactionContent)),
      'subjectId',
      serializers.serialize(object.subjectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveReactionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveReactionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'content':
          result.content = serializers.deserialize(value,
                  specifiedType: const FullType(GReactionContent))
              as GReactionContent;
          break;
        case 'subjectId':
          result.subjectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveStarInputSerializer
    implements StructuredSerializer<GRemoveStarInput> {
  @override
  final Iterable<Type> types = const [GRemoveStarInput, _$GRemoveStarInput];
  @override
  final String wireName = 'GRemoveStarInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GRemoveStarInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'starrableId',
      serializers.serialize(object.starrableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveStarInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveStarInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'starrableId':
          result.starrableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRemoveUpvoteInputSerializer
    implements StructuredSerializer<GRemoveUpvoteInput> {
  @override
  final Iterable<Type> types = const [GRemoveUpvoteInput, _$GRemoveUpvoteInput];
  @override
  final String wireName = 'GRemoveUpvoteInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRemoveUpvoteInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'subjectId',
      serializers.serialize(object.subjectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRemoveUpvoteInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRemoveUpvoteInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'subjectId':
          result.subjectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GReopenIssueInputSerializer
    implements StructuredSerializer<GReopenIssueInput> {
  @override
  final Iterable<Type> types = const [GReopenIssueInput, _$GReopenIssueInput];
  @override
  final String wireName = 'GReopenIssueInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GReopenIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'issueId',
      serializers.serialize(object.issueId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GReopenIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GReopenIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issueId':
          result.issueId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GReopenPullRequestInputSerializer
    implements StructuredSerializer<GReopenPullRequestInput> {
  @override
  final Iterable<Type> types = const [
    GReopenPullRequestInput,
    _$GReopenPullRequestInput
  ];
  @override
  final String wireName = 'GReopenPullRequestInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GReopenPullRequestInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GReopenPullRequestInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GReopenPullRequestInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GRepoAccessAuditEntryVisibilitySerializer
    implements PrimitiveSerializer<GRepoAccessAuditEntryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[GRepoAccessAuditEntryVisibility];
  @override
  final String wireName = 'GRepoAccessAuditEntryVisibility';

  @override
  Object serialize(
          Serializers serializers, GRepoAccessAuditEntryVisibility object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepoAccessAuditEntryVisibility deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepoAccessAuditEntryVisibility.valueOf(serialized as String);
}

class _$GRepoAddMemberAuditEntryVisibilitySerializer
    implements PrimitiveSerializer<GRepoAddMemberAuditEntryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[GRepoAddMemberAuditEntryVisibility];
  @override
  final String wireName = 'GRepoAddMemberAuditEntryVisibility';

  @override
  Object serialize(
          Serializers serializers, GRepoAddMemberAuditEntryVisibility object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepoAddMemberAuditEntryVisibility deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepoAddMemberAuditEntryVisibility.valueOf(serialized as String);
}

class _$GRepoArchivedAuditEntryVisibilitySerializer
    implements PrimitiveSerializer<GRepoArchivedAuditEntryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[GRepoArchivedAuditEntryVisibility];
  @override
  final String wireName = 'GRepoArchivedAuditEntryVisibility';

  @override
  Object serialize(
          Serializers serializers, GRepoArchivedAuditEntryVisibility object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepoArchivedAuditEntryVisibility deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepoArchivedAuditEntryVisibility.valueOf(serialized as String);
}

class _$GRepoChangeMergeSettingAuditEntryMergeTypeSerializer
    implements PrimitiveSerializer<GRepoChangeMergeSettingAuditEntryMergeType> {
  @override
  final Iterable<Type> types = const <Type>[
    GRepoChangeMergeSettingAuditEntryMergeType
  ];
  @override
  final String wireName = 'GRepoChangeMergeSettingAuditEntryMergeType';

  @override
  Object serialize(Serializers serializers,
          GRepoChangeMergeSettingAuditEntryMergeType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepoChangeMergeSettingAuditEntryMergeType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepoChangeMergeSettingAuditEntryMergeType.valueOf(serialized as String);
}

class _$GRepoCreateAuditEntryVisibilitySerializer
    implements PrimitiveSerializer<GRepoCreateAuditEntryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[GRepoCreateAuditEntryVisibility];
  @override
  final String wireName = 'GRepoCreateAuditEntryVisibility';

  @override
  Object serialize(
          Serializers serializers, GRepoCreateAuditEntryVisibility object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepoCreateAuditEntryVisibility deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepoCreateAuditEntryVisibility.valueOf(serialized as String);
}

class _$GRepoDestroyAuditEntryVisibilitySerializer
    implements PrimitiveSerializer<GRepoDestroyAuditEntryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[GRepoDestroyAuditEntryVisibility];
  @override
  final String wireName = 'GRepoDestroyAuditEntryVisibility';

  @override
  Object serialize(
          Serializers serializers, GRepoDestroyAuditEntryVisibility object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepoDestroyAuditEntryVisibility deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepoDestroyAuditEntryVisibility.valueOf(serialized as String);
}

class _$GRepoRemoveMemberAuditEntryVisibilitySerializer
    implements PrimitiveSerializer<GRepoRemoveMemberAuditEntryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[
    GRepoRemoveMemberAuditEntryVisibility
  ];
  @override
  final String wireName = 'GRepoRemoveMemberAuditEntryVisibility';

  @override
  Object serialize(
          Serializers serializers, GRepoRemoveMemberAuditEntryVisibility object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepoRemoveMemberAuditEntryVisibility deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepoRemoveMemberAuditEntryVisibility.valueOf(serialized as String);
}

class _$GReportedContentClassifiersSerializer
    implements PrimitiveSerializer<GReportedContentClassifiers> {
  @override
  final Iterable<Type> types = const <Type>[GReportedContentClassifiers];
  @override
  final String wireName = 'GReportedContentClassifiers';

  @override
  Object serialize(Serializers serializers, GReportedContentClassifiers object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GReportedContentClassifiers deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GReportedContentClassifiers.valueOf(serialized as String);
}

class _$GRepositoryAffiliationSerializer
    implements PrimitiveSerializer<GRepositoryAffiliation> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryAffiliation];
  @override
  final String wireName = 'GRepositoryAffiliation';

  @override
  Object serialize(Serializers serializers, GRepositoryAffiliation object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryAffiliation deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryAffiliation.valueOf(serialized as String);
}

class _$GRepositoryContributionTypeSerializer
    implements PrimitiveSerializer<GRepositoryContributionType> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryContributionType];
  @override
  final String wireName = 'GRepositoryContributionType';

  @override
  Object serialize(Serializers serializers, GRepositoryContributionType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryContributionType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryContributionType.valueOf(serialized as String);
}

class _$GRepositoryInteractionLimitSerializer
    implements PrimitiveSerializer<GRepositoryInteractionLimit> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryInteractionLimit];
  @override
  final String wireName = 'GRepositoryInteractionLimit';

  @override
  Object serialize(Serializers serializers, GRepositoryInteractionLimit object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryInteractionLimit deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryInteractionLimit.valueOf(serialized as String);
}

class _$GRepositoryInteractionLimitExpirySerializer
    implements PrimitiveSerializer<GRepositoryInteractionLimitExpiry> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryInteractionLimitExpiry];
  @override
  final String wireName = 'GRepositoryInteractionLimitExpiry';

  @override
  Object serialize(
          Serializers serializers, GRepositoryInteractionLimitExpiry object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryInteractionLimitExpiry deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryInteractionLimitExpiry.valueOf(serialized as String);
}

class _$GRepositoryInteractionLimitOriginSerializer
    implements PrimitiveSerializer<GRepositoryInteractionLimitOrigin> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryInteractionLimitOrigin];
  @override
  final String wireName = 'GRepositoryInteractionLimitOrigin';

  @override
  Object serialize(
          Serializers serializers, GRepositoryInteractionLimitOrigin object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryInteractionLimitOrigin deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryInteractionLimitOrigin.valueOf(serialized as String);
}

class _$GRepositoryInvitationOrderSerializer
    implements StructuredSerializer<GRepositoryInvitationOrder> {
  @override
  final Iterable<Type> types = const [
    GRepositoryInvitationOrder,
    _$GRepositoryInvitationOrder
  ];
  @override
  final String wireName = 'GRepositoryInvitationOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRepositoryInvitationOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GRepositoryInvitationOrderField)),
    ];

    return result;
  }

  @override
  GRepositoryInvitationOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRepositoryInvitationOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GRepositoryInvitationOrderField))
              as GRepositoryInvitationOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GRepositoryInvitationOrderFieldSerializer
    implements PrimitiveSerializer<GRepositoryInvitationOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryInvitationOrderField];
  @override
  final String wireName = 'GRepositoryInvitationOrderField';

  @override
  Object serialize(
          Serializers serializers, GRepositoryInvitationOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryInvitationOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryInvitationOrderField.valueOf(serialized as String);
}

class _$GRepositoryLockReasonSerializer
    implements PrimitiveSerializer<GRepositoryLockReason> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryLockReason];
  @override
  final String wireName = 'GRepositoryLockReason';

  @override
  Object serialize(Serializers serializers, GRepositoryLockReason object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryLockReason deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryLockReason.valueOf(serialized as String);
}

class _$GRepositoryOrderSerializer
    implements StructuredSerializer<GRepositoryOrder> {
  @override
  final Iterable<Type> types = const [GRepositoryOrder, _$GRepositoryOrder];
  @override
  final String wireName = 'GRepositoryOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GRepositoryOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GRepositoryOrderField)),
    ];

    return result;
  }

  @override
  GRepositoryOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRepositoryOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GRepositoryOrderField))
              as GRepositoryOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GRepositoryOrderFieldSerializer
    implements PrimitiveSerializer<GRepositoryOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryOrderField];
  @override
  final String wireName = 'GRepositoryOrderField';

  @override
  Object serialize(Serializers serializers, GRepositoryOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryOrderField.valueOf(serialized as String);
}

class _$GRepositoryPermissionSerializer
    implements PrimitiveSerializer<GRepositoryPermission> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryPermission];
  @override
  final String wireName = 'GRepositoryPermission';

  @override
  Object serialize(Serializers serializers, GRepositoryPermission object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryPermission deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryPermission.valueOf(serialized as String);
}

class _$GRepositoryPrivacySerializer
    implements PrimitiveSerializer<GRepositoryPrivacy> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryPrivacy];
  @override
  final String wireName = 'GRepositoryPrivacy';

  @override
  Object serialize(Serializers serializers, GRepositoryPrivacy object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryPrivacy deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryPrivacy.valueOf(serialized as String);
}

class _$GRepositoryVisibilitySerializer
    implements PrimitiveSerializer<GRepositoryVisibility> {
  @override
  final Iterable<Type> types = const <Type>[GRepositoryVisibility];
  @override
  final String wireName = 'GRepositoryVisibility';

  @override
  Object serialize(Serializers serializers, GRepositoryVisibility object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRepositoryVisibility deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRepositoryVisibility.valueOf(serialized as String);
}

class _$GRequestReviewsInputSerializer
    implements StructuredSerializer<GRequestReviewsInput> {
  @override
  final Iterable<Type> types = const [
    GRequestReviewsInput,
    _$GRequestReviewsInput
  ];
  @override
  final String wireName = 'GRequestReviewsInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRequestReviewsInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.teamIds;
    if (value != null) {
      result
        ..add('teamIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.union;
    if (value != null) {
      result
        ..add('union')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.userIds;
    if (value != null) {
      result
        ..add('userIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    return result;
  }

  @override
  GRequestReviewsInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRequestReviewsInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'teamIds':
          result.teamIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'union':
          result.union = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'userIds':
          result.userIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
      }
    }

    return result.build();
  }
}

class _$GRequestableCheckStatusStateSerializer
    implements PrimitiveSerializer<GRequestableCheckStatusState> {
  @override
  final Iterable<Type> types = const <Type>[GRequestableCheckStatusState];
  @override
  final String wireName = 'GRequestableCheckStatusState';

  @override
  Object serialize(Serializers serializers, GRequestableCheckStatusState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GRequestableCheckStatusState deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GRequestableCheckStatusState.valueOf(serialized as String);
}

class _$GRerequestCheckSuiteInputSerializer
    implements StructuredSerializer<GRerequestCheckSuiteInput> {
  @override
  final Iterable<Type> types = const [
    GRerequestCheckSuiteInput,
    _$GRerequestCheckSuiteInput
  ];
  @override
  final String wireName = 'GRerequestCheckSuiteInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GRerequestCheckSuiteInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'checkSuiteId',
      serializers.serialize(object.checkSuiteId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GRerequestCheckSuiteInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GRerequestCheckSuiteInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'checkSuiteId':
          result.checkSuiteId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GResolveReviewThreadInputSerializer
    implements StructuredSerializer<GResolveReviewThreadInput> {
  @override
  final Iterable<Type> types = const [
    GResolveReviewThreadInput,
    _$GResolveReviewThreadInput
  ];
  @override
  final String wireName = 'GResolveReviewThreadInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GResolveReviewThreadInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'threadId',
      serializers.serialize(object.threadId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GResolveReviewThreadInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GResolveReviewThreadInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'threadId':
          result.threadId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GSamlDigestAlgorithmSerializer
    implements PrimitiveSerializer<GSamlDigestAlgorithm> {
  @override
  final Iterable<Type> types = const <Type>[GSamlDigestAlgorithm];
  @override
  final String wireName = 'GSamlDigestAlgorithm';

  @override
  Object serialize(Serializers serializers, GSamlDigestAlgorithm object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSamlDigestAlgorithm deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSamlDigestAlgorithm.valueOf(serialized as String);
}

class _$GSamlSignatureAlgorithmSerializer
    implements PrimitiveSerializer<GSamlSignatureAlgorithm> {
  @override
  final Iterable<Type> types = const <Type>[GSamlSignatureAlgorithm];
  @override
  final String wireName = 'GSamlSignatureAlgorithm';

  @override
  Object serialize(Serializers serializers, GSamlSignatureAlgorithm object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSamlSignatureAlgorithm deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSamlSignatureAlgorithm.valueOf(serialized as String);
}

class _$GSavedReplyOrderSerializer
    implements StructuredSerializer<GSavedReplyOrder> {
  @override
  final Iterable<Type> types = const [GSavedReplyOrder, _$GSavedReplyOrder];
  @override
  final String wireName = 'GSavedReplyOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GSavedReplyOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GSavedReplyOrderField)),
    ];

    return result;
  }

  @override
  GSavedReplyOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSavedReplyOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GSavedReplyOrderField))
              as GSavedReplyOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GSavedReplyOrderFieldSerializer
    implements PrimitiveSerializer<GSavedReplyOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GSavedReplyOrderField];
  @override
  final String wireName = 'GSavedReplyOrderField';

  @override
  Object serialize(Serializers serializers, GSavedReplyOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSavedReplyOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSavedReplyOrderField.valueOf(serialized as String);
}

class _$GSearchTypeSerializer implements PrimitiveSerializer<GSearchType> {
  @override
  final Iterable<Type> types = const <Type>[GSearchType];
  @override
  final String wireName = 'GSearchType';

  @override
  Object serialize(Serializers serializers, GSearchType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSearchType deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSearchType.valueOf(serialized as String);
}

class _$GSecurityAdvisoryEcosystemSerializer
    implements PrimitiveSerializer<GSecurityAdvisoryEcosystem> {
  @override
  final Iterable<Type> types = const <Type>[GSecurityAdvisoryEcosystem];
  @override
  final String wireName = 'GSecurityAdvisoryEcosystem';

  @override
  Object serialize(Serializers serializers, GSecurityAdvisoryEcosystem object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSecurityAdvisoryEcosystem deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSecurityAdvisoryEcosystem.valueOf(serialized as String);
}

class _$GSecurityAdvisoryIdentifierFilterSerializer
    implements StructuredSerializer<GSecurityAdvisoryIdentifierFilter> {
  @override
  final Iterable<Type> types = const [
    GSecurityAdvisoryIdentifierFilter,
    _$GSecurityAdvisoryIdentifierFilter
  ];
  @override
  final String wireName = 'GSecurityAdvisoryIdentifierFilter';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSecurityAdvisoryIdentifierFilter object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'type',
      serializers.serialize(object.type,
          specifiedType: const FullType(GSecurityAdvisoryIdentifierType)),
      'value',
      serializers.serialize(object.value,
          specifiedType: const FullType(String)),
    ];

    return result;
  }

  @override
  GSecurityAdvisoryIdentifierFilter deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSecurityAdvisoryIdentifierFilterBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'type':
          result.type = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GSecurityAdvisoryIdentifierType))
              as GSecurityAdvisoryIdentifierType;
          break;
        case 'value':
          result.value = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GSecurityAdvisoryIdentifierTypeSerializer
    implements PrimitiveSerializer<GSecurityAdvisoryIdentifierType> {
  @override
  final Iterable<Type> types = const <Type>[GSecurityAdvisoryIdentifierType];
  @override
  final String wireName = 'GSecurityAdvisoryIdentifierType';

  @override
  Object serialize(
          Serializers serializers, GSecurityAdvisoryIdentifierType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSecurityAdvisoryIdentifierType deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSecurityAdvisoryIdentifierType.valueOf(serialized as String);
}

class _$GSecurityAdvisoryOrderSerializer
    implements StructuredSerializer<GSecurityAdvisoryOrder> {
  @override
  final Iterable<Type> types = const [
    GSecurityAdvisoryOrder,
    _$GSecurityAdvisoryOrder
  ];
  @override
  final String wireName = 'GSecurityAdvisoryOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSecurityAdvisoryOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GSecurityAdvisoryOrderField)),
    ];

    return result;
  }

  @override
  GSecurityAdvisoryOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSecurityAdvisoryOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GSecurityAdvisoryOrderField))
              as GSecurityAdvisoryOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GSecurityAdvisoryOrderFieldSerializer
    implements PrimitiveSerializer<GSecurityAdvisoryOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GSecurityAdvisoryOrderField];
  @override
  final String wireName = 'GSecurityAdvisoryOrderField';

  @override
  Object serialize(Serializers serializers, GSecurityAdvisoryOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSecurityAdvisoryOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSecurityAdvisoryOrderField.valueOf(serialized as String);
}

class _$GSecurityAdvisorySeveritySerializer
    implements PrimitiveSerializer<GSecurityAdvisorySeverity> {
  @override
  final Iterable<Type> types = const <Type>[GSecurityAdvisorySeverity];
  @override
  final String wireName = 'GSecurityAdvisorySeverity';

  @override
  Object serialize(Serializers serializers, GSecurityAdvisorySeverity object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSecurityAdvisorySeverity deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSecurityAdvisorySeverity.valueOf(serialized as String);
}

class _$GSecurityVulnerabilityOrderSerializer
    implements StructuredSerializer<GSecurityVulnerabilityOrder> {
  @override
  final Iterable<Type> types = const [
    GSecurityVulnerabilityOrder,
    _$GSecurityVulnerabilityOrder
  ];
  @override
  final String wireName = 'GSecurityVulnerabilityOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSecurityVulnerabilityOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GSecurityVulnerabilityOrderField)),
    ];

    return result;
  }

  @override
  GSecurityVulnerabilityOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSecurityVulnerabilityOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GSecurityVulnerabilityOrderField))
              as GSecurityVulnerabilityOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GSecurityVulnerabilityOrderFieldSerializer
    implements PrimitiveSerializer<GSecurityVulnerabilityOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GSecurityVulnerabilityOrderField];
  @override
  final String wireName = 'GSecurityVulnerabilityOrderField';

  @override
  Object serialize(
          Serializers serializers, GSecurityVulnerabilityOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSecurityVulnerabilityOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSecurityVulnerabilityOrderField.valueOf(serialized as String);
}

class _$GSetEnterpriseIdentityProviderInputSerializer
    implements StructuredSerializer<GSetEnterpriseIdentityProviderInput> {
  @override
  final Iterable<Type> types = const [
    GSetEnterpriseIdentityProviderInput,
    _$GSetEnterpriseIdentityProviderInput
  ];
  @override
  final String wireName = 'GSetEnterpriseIdentityProviderInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSetEnterpriseIdentityProviderInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'digestMethod',
      serializers.serialize(object.digestMethod,
          specifiedType: const FullType(GSamlDigestAlgorithm)),
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'idpCertificate',
      serializers.serialize(object.idpCertificate,
          specifiedType: const FullType(String)),
      'signatureMethod',
      serializers.serialize(object.signatureMethod,
          specifiedType: const FullType(GSamlSignatureAlgorithm)),
      'ssoUrl',
      serializers.serialize(object.ssoUrl,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.issuer;
    if (value != null) {
      result
        ..add('issuer')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GSetEnterpriseIdentityProviderInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSetEnterpriseIdentityProviderInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'digestMethod':
          result.digestMethod = serializers.deserialize(value,
                  specifiedType: const FullType(GSamlDigestAlgorithm))
              as GSamlDigestAlgorithm;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'idpCertificate':
          result.idpCertificate = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issuer':
          result.issuer = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'signatureMethod':
          result.signatureMethod = serializers.deserialize(value,
                  specifiedType: const FullType(GSamlSignatureAlgorithm))
              as GSamlSignatureAlgorithm;
          break;
        case 'ssoUrl':
          result.ssoUrl = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GSetOrganizationInteractionLimitInputSerializer
    implements StructuredSerializer<GSetOrganizationInteractionLimitInput> {
  @override
  final Iterable<Type> types = const [
    GSetOrganizationInteractionLimitInput,
    _$GSetOrganizationInteractionLimitInput
  ];
  @override
  final String wireName = 'GSetOrganizationInteractionLimitInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSetOrganizationInteractionLimitInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'limit',
      serializers.serialize(object.limit,
          specifiedType: const FullType(GRepositoryInteractionLimit)),
      'organizationId',
      serializers.serialize(object.organizationId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.expiry;
    if (value != null) {
      result
        ..add('expiry')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GRepositoryInteractionLimitExpiry)));
    }
    return result;
  }

  @override
  GSetOrganizationInteractionLimitInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSetOrganizationInteractionLimitInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'expiry':
          result.expiry = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GRepositoryInteractionLimitExpiry))
              as GRepositoryInteractionLimitExpiry;
          break;
        case 'limit':
          result.limit = serializers.deserialize(value,
                  specifiedType: const FullType(GRepositoryInteractionLimit))
              as GRepositoryInteractionLimit;
          break;
        case 'organizationId':
          result.organizationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GSetRepositoryInteractionLimitInputSerializer
    implements StructuredSerializer<GSetRepositoryInteractionLimitInput> {
  @override
  final Iterable<Type> types = const [
    GSetRepositoryInteractionLimitInput,
    _$GSetRepositoryInteractionLimitInput
  ];
  @override
  final String wireName = 'GSetRepositoryInteractionLimitInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSetRepositoryInteractionLimitInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'limit',
      serializers.serialize(object.limit,
          specifiedType: const FullType(GRepositoryInteractionLimit)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.expiry;
    if (value != null) {
      result
        ..add('expiry')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GRepositoryInteractionLimitExpiry)));
    }
    return result;
  }

  @override
  GSetRepositoryInteractionLimitInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSetRepositoryInteractionLimitInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'expiry':
          result.expiry = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GRepositoryInteractionLimitExpiry))
              as GRepositoryInteractionLimitExpiry;
          break;
        case 'limit':
          result.limit = serializers.deserialize(value,
                  specifiedType: const FullType(GRepositoryInteractionLimit))
              as GRepositoryInteractionLimit;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GSetUserInteractionLimitInputSerializer
    implements StructuredSerializer<GSetUserInteractionLimitInput> {
  @override
  final Iterable<Type> types = const [
    GSetUserInteractionLimitInput,
    _$GSetUserInteractionLimitInput
  ];
  @override
  final String wireName = 'GSetUserInteractionLimitInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSetUserInteractionLimitInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'limit',
      serializers.serialize(object.limit,
          specifiedType: const FullType(GRepositoryInteractionLimit)),
      'userId',
      serializers.serialize(object.userId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.expiry;
    if (value != null) {
      result
        ..add('expiry')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GRepositoryInteractionLimitExpiry)));
    }
    return result;
  }

  @override
  GSetUserInteractionLimitInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSetUserInteractionLimitInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'expiry':
          result.expiry = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GRepositoryInteractionLimitExpiry))
              as GRepositoryInteractionLimitExpiry;
          break;
        case 'limit':
          result.limit = serializers.deserialize(value,
                  specifiedType: const FullType(GRepositoryInteractionLimit))
              as GRepositoryInteractionLimit;
          break;
        case 'userId':
          result.userId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GSponsorableOrderSerializer
    implements StructuredSerializer<GSponsorableOrder> {
  @override
  final Iterable<Type> types = const [GSponsorableOrder, _$GSponsorableOrder];
  @override
  final String wireName = 'GSponsorableOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GSponsorableOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GSponsorableOrderField)),
    ];

    return result;
  }

  @override
  GSponsorableOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSponsorableOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GSponsorableOrderField))
              as GSponsorableOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GSponsorableOrderFieldSerializer
    implements PrimitiveSerializer<GSponsorableOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GSponsorableOrderField];
  @override
  final String wireName = 'GSponsorableOrderField';

  @override
  Object serialize(Serializers serializers, GSponsorableOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSponsorableOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSponsorableOrderField.valueOf(serialized as String);
}

class _$GSponsorsGoalKindSerializer
    implements PrimitiveSerializer<GSponsorsGoalKind> {
  @override
  final Iterable<Type> types = const <Type>[GSponsorsGoalKind];
  @override
  final String wireName = 'GSponsorsGoalKind';

  @override
  Object serialize(Serializers serializers, GSponsorsGoalKind object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSponsorsGoalKind deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSponsorsGoalKind.valueOf(serialized as String);
}

class _$GSponsorsTierOrderSerializer
    implements StructuredSerializer<GSponsorsTierOrder> {
  @override
  final Iterable<Type> types = const [GSponsorsTierOrder, _$GSponsorsTierOrder];
  @override
  final String wireName = 'GSponsorsTierOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSponsorsTierOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GSponsorsTierOrderField)),
    ];

    return result;
  }

  @override
  GSponsorsTierOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSponsorsTierOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GSponsorsTierOrderField))
              as GSponsorsTierOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GSponsorsTierOrderFieldSerializer
    implements PrimitiveSerializer<GSponsorsTierOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GSponsorsTierOrderField];
  @override
  final String wireName = 'GSponsorsTierOrderField';

  @override
  Object serialize(Serializers serializers, GSponsorsTierOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSponsorsTierOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSponsorsTierOrderField.valueOf(serialized as String);
}

class _$GSponsorshipOrderSerializer
    implements StructuredSerializer<GSponsorshipOrder> {
  @override
  final Iterable<Type> types = const [GSponsorshipOrder, _$GSponsorshipOrder];
  @override
  final String wireName = 'GSponsorshipOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GSponsorshipOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GSponsorshipOrderField)),
    ];

    return result;
  }

  @override
  GSponsorshipOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSponsorshipOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GSponsorshipOrderField))
              as GSponsorshipOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GSponsorshipOrderFieldSerializer
    implements PrimitiveSerializer<GSponsorshipOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GSponsorshipOrderField];
  @override
  final String wireName = 'GSponsorshipOrderField';

  @override
  Object serialize(Serializers serializers, GSponsorshipOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSponsorshipOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSponsorshipOrderField.valueOf(serialized as String);
}

class _$GSponsorshipPrivacySerializer
    implements PrimitiveSerializer<GSponsorshipPrivacy> {
  @override
  final Iterable<Type> types = const <Type>[GSponsorshipPrivacy];
  @override
  final String wireName = 'GSponsorshipPrivacy';

  @override
  Object serialize(Serializers serializers, GSponsorshipPrivacy object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSponsorshipPrivacy deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSponsorshipPrivacy.valueOf(serialized as String);
}

class _$GStarOrderSerializer implements StructuredSerializer<GStarOrder> {
  @override
  final Iterable<Type> types = const [GStarOrder, _$GStarOrder];
  @override
  final String wireName = 'GStarOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GStarOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GStarOrderField)),
    ];

    return result;
  }

  @override
  GStarOrder deserialize(Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GStarOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GStarOrderField))
              as GStarOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GStarOrderFieldSerializer
    implements PrimitiveSerializer<GStarOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GStarOrderField];
  @override
  final String wireName = 'GStarOrderField';

  @override
  Object serialize(Serializers serializers, GStarOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GStarOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GStarOrderField.valueOf(serialized as String);
}

class _$GStatusStateSerializer implements PrimitiveSerializer<GStatusState> {
  @override
  final Iterable<Type> types = const <Type>[GStatusState];
  @override
  final String wireName = 'GStatusState';

  @override
  Object serialize(Serializers serializers, GStatusState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GStatusState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GStatusState.valueOf(serialized as String);
}

class _$GSubmitPullRequestReviewInputSerializer
    implements StructuredSerializer<GSubmitPullRequestReviewInput> {
  @override
  final Iterable<Type> types = const [
    GSubmitPullRequestReviewInput,
    _$GSubmitPullRequestReviewInput
  ];
  @override
  final String wireName = 'GSubmitPullRequestReviewInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GSubmitPullRequestReviewInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'event',
      serializers.serialize(object.event,
          specifiedType: const FullType(GPullRequestReviewEvent)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.pullRequestId;
    if (value != null) {
      result
        ..add('pullRequestId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.pullRequestReviewId;
    if (value != null) {
      result
        ..add('pullRequestReviewId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GSubmitPullRequestReviewInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GSubmitPullRequestReviewInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'event':
          result.event = serializers.deserialize(value,
                  specifiedType: const FullType(GPullRequestReviewEvent))
              as GPullRequestReviewEvent;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestReviewId':
          result.pullRequestReviewId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GSubscriptionStateSerializer
    implements PrimitiveSerializer<GSubscriptionState> {
  @override
  final Iterable<Type> types = const <Type>[GSubscriptionState];
  @override
  final String wireName = 'GSubscriptionState';

  @override
  Object serialize(Serializers serializers, GSubscriptionState object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GSubscriptionState deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GSubscriptionState.valueOf(serialized as String);
}

class _$GTeamDiscussionCommentOrderSerializer
    implements StructuredSerializer<GTeamDiscussionCommentOrder> {
  @override
  final Iterable<Type> types = const [
    GTeamDiscussionCommentOrder,
    _$GTeamDiscussionCommentOrder
  ];
  @override
  final String wireName = 'GTeamDiscussionCommentOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GTeamDiscussionCommentOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GTeamDiscussionCommentOrderField)),
    ];

    return result;
  }

  @override
  GTeamDiscussionCommentOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GTeamDiscussionCommentOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GTeamDiscussionCommentOrderField))
              as GTeamDiscussionCommentOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GTeamDiscussionCommentOrderFieldSerializer
    implements PrimitiveSerializer<GTeamDiscussionCommentOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GTeamDiscussionCommentOrderField];
  @override
  final String wireName = 'GTeamDiscussionCommentOrderField';

  @override
  Object serialize(
          Serializers serializers, GTeamDiscussionCommentOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamDiscussionCommentOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamDiscussionCommentOrderField.valueOf(serialized as String);
}

class _$GTeamDiscussionOrderSerializer
    implements StructuredSerializer<GTeamDiscussionOrder> {
  @override
  final Iterable<Type> types = const [
    GTeamDiscussionOrder,
    _$GTeamDiscussionOrder
  ];
  @override
  final String wireName = 'GTeamDiscussionOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GTeamDiscussionOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GTeamDiscussionOrderField)),
    ];

    return result;
  }

  @override
  GTeamDiscussionOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GTeamDiscussionOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GTeamDiscussionOrderField))
              as GTeamDiscussionOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GTeamDiscussionOrderFieldSerializer
    implements PrimitiveSerializer<GTeamDiscussionOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GTeamDiscussionOrderField];
  @override
  final String wireName = 'GTeamDiscussionOrderField';

  @override
  Object serialize(Serializers serializers, GTeamDiscussionOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamDiscussionOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamDiscussionOrderField.valueOf(serialized as String);
}

class _$GTeamMemberOrderSerializer
    implements StructuredSerializer<GTeamMemberOrder> {
  @override
  final Iterable<Type> types = const [GTeamMemberOrder, _$GTeamMemberOrder];
  @override
  final String wireName = 'GTeamMemberOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GTeamMemberOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GTeamMemberOrderField)),
    ];

    return result;
  }

  @override
  GTeamMemberOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GTeamMemberOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GTeamMemberOrderField))
              as GTeamMemberOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GTeamMemberOrderFieldSerializer
    implements PrimitiveSerializer<GTeamMemberOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GTeamMemberOrderField];
  @override
  final String wireName = 'GTeamMemberOrderField';

  @override
  Object serialize(Serializers serializers, GTeamMemberOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamMemberOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamMemberOrderField.valueOf(serialized as String);
}

class _$GTeamMemberRoleSerializer
    implements PrimitiveSerializer<GTeamMemberRole> {
  @override
  final Iterable<Type> types = const <Type>[GTeamMemberRole];
  @override
  final String wireName = 'GTeamMemberRole';

  @override
  Object serialize(Serializers serializers, GTeamMemberRole object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamMemberRole deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamMemberRole.valueOf(serialized as String);
}

class _$GTeamMembershipTypeSerializer
    implements PrimitiveSerializer<GTeamMembershipType> {
  @override
  final Iterable<Type> types = const <Type>[GTeamMembershipType];
  @override
  final String wireName = 'GTeamMembershipType';

  @override
  Object serialize(Serializers serializers, GTeamMembershipType object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamMembershipType deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamMembershipType.valueOf(serialized as String);
}

class _$GTeamOrderSerializer implements StructuredSerializer<GTeamOrder> {
  @override
  final Iterable<Type> types = const [GTeamOrder, _$GTeamOrder];
  @override
  final String wireName = 'GTeamOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GTeamOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GTeamOrderField)),
    ];

    return result;
  }

  @override
  GTeamOrder deserialize(Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GTeamOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GTeamOrderField))
              as GTeamOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GTeamOrderFieldSerializer
    implements PrimitiveSerializer<GTeamOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GTeamOrderField];
  @override
  final String wireName = 'GTeamOrderField';

  @override
  Object serialize(Serializers serializers, GTeamOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamOrderField.valueOf(serialized as String);
}

class _$GTeamPrivacySerializer implements PrimitiveSerializer<GTeamPrivacy> {
  @override
  final Iterable<Type> types = const <Type>[GTeamPrivacy];
  @override
  final String wireName = 'GTeamPrivacy';

  @override
  Object serialize(Serializers serializers, GTeamPrivacy object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamPrivacy deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamPrivacy.valueOf(serialized as String);
}

class _$GTeamRepositoryOrderSerializer
    implements StructuredSerializer<GTeamRepositoryOrder> {
  @override
  final Iterable<Type> types = const [
    GTeamRepositoryOrder,
    _$GTeamRepositoryOrder
  ];
  @override
  final String wireName = 'GTeamRepositoryOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GTeamRepositoryOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GTeamRepositoryOrderField)),
    ];

    return result;
  }

  @override
  GTeamRepositoryOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GTeamRepositoryOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GTeamRepositoryOrderField))
              as GTeamRepositoryOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GTeamRepositoryOrderFieldSerializer
    implements PrimitiveSerializer<GTeamRepositoryOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GTeamRepositoryOrderField];
  @override
  final String wireName = 'GTeamRepositoryOrderField';

  @override
  Object serialize(Serializers serializers, GTeamRepositoryOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamRepositoryOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamRepositoryOrderField.valueOf(serialized as String);
}

class _$GTeamRoleSerializer implements PrimitiveSerializer<GTeamRole> {
  @override
  final Iterable<Type> types = const <Type>[GTeamRole];
  @override
  final String wireName = 'GTeamRole';

  @override
  Object serialize(Serializers serializers, GTeamRole object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTeamRole deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTeamRole.valueOf(serialized as String);
}

class _$GTopicSuggestionDeclineReasonSerializer
    implements PrimitiveSerializer<GTopicSuggestionDeclineReason> {
  @override
  final Iterable<Type> types = const <Type>[GTopicSuggestionDeclineReason];
  @override
  final String wireName = 'GTopicSuggestionDeclineReason';

  @override
  Object serialize(
          Serializers serializers, GTopicSuggestionDeclineReason object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GTopicSuggestionDeclineReason deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GTopicSuggestionDeclineReason.valueOf(serialized as String);
}

class _$GTransferIssueInputSerializer
    implements StructuredSerializer<GTransferIssueInput> {
  @override
  final Iterable<Type> types = const [
    GTransferIssueInput,
    _$GTransferIssueInput
  ];
  @override
  final String wireName = 'GTransferIssueInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GTransferIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'issueId',
      serializers.serialize(object.issueId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GTransferIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GTransferIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issueId':
          result.issueId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnarchiveRepositoryInputSerializer
    implements StructuredSerializer<GUnarchiveRepositoryInput> {
  @override
  final Iterable<Type> types = const [
    GUnarchiveRepositoryInput,
    _$GUnarchiveRepositoryInput
  ];
  @override
  final String wireName = 'GUnarchiveRepositoryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnarchiveRepositoryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnarchiveRepositoryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnarchiveRepositoryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnfollowUserInputSerializer
    implements StructuredSerializer<GUnfollowUserInput> {
  @override
  final Iterable<Type> types = const [GUnfollowUserInput, _$GUnfollowUserInput];
  @override
  final String wireName = 'GUnfollowUserInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnfollowUserInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'userId',
      serializers.serialize(object.userId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnfollowUserInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnfollowUserInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'userId':
          result.userId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnlinkRepositoryFromProjectInputSerializer
    implements StructuredSerializer<GUnlinkRepositoryFromProjectInput> {
  @override
  final Iterable<Type> types = const [
    GUnlinkRepositoryFromProjectInput,
    _$GUnlinkRepositoryFromProjectInput
  ];
  @override
  final String wireName = 'GUnlinkRepositoryFromProjectInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnlinkRepositoryFromProjectInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'projectId',
      serializers.serialize(object.projectId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnlinkRepositoryFromProjectInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnlinkRepositoryFromProjectInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectId':
          result.projectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnlockLockableInputSerializer
    implements StructuredSerializer<GUnlockLockableInput> {
  @override
  final Iterable<Type> types = const [
    GUnlockLockableInput,
    _$GUnlockLockableInput
  ];
  @override
  final String wireName = 'GUnlockLockableInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnlockLockableInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'lockableId',
      serializers.serialize(object.lockableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnlockLockableInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnlockLockableInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'lockableId':
          result.lockableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnmarkDiscussionCommentAsAnswerInputSerializer
    implements StructuredSerializer<GUnmarkDiscussionCommentAsAnswerInput> {
  @override
  final Iterable<Type> types = const [
    GUnmarkDiscussionCommentAsAnswerInput,
    _$GUnmarkDiscussionCommentAsAnswerInput
  ];
  @override
  final String wireName = 'GUnmarkDiscussionCommentAsAnswerInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnmarkDiscussionCommentAsAnswerInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnmarkDiscussionCommentAsAnswerInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnmarkDiscussionCommentAsAnswerInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnmarkFileAsViewedInputSerializer
    implements StructuredSerializer<GUnmarkFileAsViewedInput> {
  @override
  final Iterable<Type> types = const [
    GUnmarkFileAsViewedInput,
    _$GUnmarkFileAsViewedInput
  ];
  @override
  final String wireName = 'GUnmarkFileAsViewedInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnmarkFileAsViewedInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'path',
      serializers.serialize(object.path, specifiedType: const FullType(String)),
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnmarkFileAsViewedInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnmarkFileAsViewedInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'path':
          result.path = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnmarkIssueAsDuplicateInputSerializer
    implements StructuredSerializer<GUnmarkIssueAsDuplicateInput> {
  @override
  final Iterable<Type> types = const [
    GUnmarkIssueAsDuplicateInput,
    _$GUnmarkIssueAsDuplicateInput
  ];
  @override
  final String wireName = 'GUnmarkIssueAsDuplicateInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnmarkIssueAsDuplicateInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'canonicalId',
      serializers.serialize(object.canonicalId,
          specifiedType: const FullType(String)),
      'duplicateId',
      serializers.serialize(object.duplicateId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnmarkIssueAsDuplicateInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnmarkIssueAsDuplicateInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'canonicalId':
          result.canonicalId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'duplicateId':
          result.duplicateId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnminimizeCommentInputSerializer
    implements StructuredSerializer<GUnminimizeCommentInput> {
  @override
  final Iterable<Type> types = const [
    GUnminimizeCommentInput,
    _$GUnminimizeCommentInput
  ];
  @override
  final String wireName = 'GUnminimizeCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnminimizeCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'subjectId',
      serializers.serialize(object.subjectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnminimizeCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnminimizeCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'subjectId':
          result.subjectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnpinIssueInputSerializer
    implements StructuredSerializer<GUnpinIssueInput> {
  @override
  final Iterable<Type> types = const [GUnpinIssueInput, _$GUnpinIssueInput];
  @override
  final String wireName = 'GUnpinIssueInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GUnpinIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'issueId',
      serializers.serialize(object.issueId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnpinIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnpinIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'issueId':
          result.issueId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUnresolveReviewThreadInputSerializer
    implements StructuredSerializer<GUnresolveReviewThreadInput> {
  @override
  final Iterable<Type> types = const [
    GUnresolveReviewThreadInput,
    _$GUnresolveReviewThreadInput
  ];
  @override
  final String wireName = 'GUnresolveReviewThreadInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUnresolveReviewThreadInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'threadId',
      serializers.serialize(object.threadId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUnresolveReviewThreadInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUnresolveReviewThreadInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'threadId':
          result.threadId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateBranchProtectionRuleInputSerializer
    implements StructuredSerializer<GUpdateBranchProtectionRuleInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateBranchProtectionRuleInput,
    _$GUpdateBranchProtectionRuleInput
  ];
  @override
  final String wireName = 'GUpdateBranchProtectionRuleInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateBranchProtectionRuleInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'branchProtectionRuleId',
      serializers.serialize(object.branchProtectionRuleId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.allowsDeletions;
    if (value != null) {
      result
        ..add('allowsDeletions')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.allowsForcePushes;
    if (value != null) {
      result
        ..add('allowsForcePushes')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.dismissesStaleReviews;
    if (value != null) {
      result
        ..add('dismissesStaleReviews')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.isAdminEnforced;
    if (value != null) {
      result
        ..add('isAdminEnforced')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.pattern;
    if (value != null) {
      result
        ..add('pattern')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.pushActorIds;
    if (value != null) {
      result
        ..add('pushActorIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.requiredApprovingReviewCount;
    if (value != null) {
      result
        ..add('requiredApprovingReviewCount')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    value = object.requiredStatusCheckContexts;
    if (value != null) {
      result
        ..add('requiredStatusCheckContexts')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.requiresApprovingReviews;
    if (value != null) {
      result
        ..add('requiresApprovingReviews')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresCodeOwnerReviews;
    if (value != null) {
      result
        ..add('requiresCodeOwnerReviews')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresCommitSignatures;
    if (value != null) {
      result
        ..add('requiresCommitSignatures')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresLinearHistory;
    if (value != null) {
      result
        ..add('requiresLinearHistory')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresStatusChecks;
    if (value != null) {
      result
        ..add('requiresStatusChecks')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.requiresStrictStatusChecks;
    if (value != null) {
      result
        ..add('requiresStrictStatusChecks')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.restrictsPushes;
    if (value != null) {
      result
        ..add('restrictsPushes')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.restrictsReviewDismissals;
    if (value != null) {
      result
        ..add('restrictsReviewDismissals')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.reviewDismissalActorIds;
    if (value != null) {
      result
        ..add('reviewDismissalActorIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    return result;
  }

  @override
  GUpdateBranchProtectionRuleInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateBranchProtectionRuleInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'allowsDeletions':
          result.allowsDeletions = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'allowsForcePushes':
          result.allowsForcePushes = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'branchProtectionRuleId':
          result.branchProtectionRuleId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'dismissesStaleReviews':
          result.dismissesStaleReviews = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'isAdminEnforced':
          result.isAdminEnforced = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'pattern':
          result.pattern = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pushActorIds':
          result.pushActorIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'requiredApprovingReviewCount':
          result.requiredApprovingReviewCount = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
        case 'requiredStatusCheckContexts':
          result.requiredStatusCheckContexts.replace(serializers.deserialize(
                  value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'requiresApprovingReviews':
          result.requiresApprovingReviews = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresCodeOwnerReviews':
          result.requiresCodeOwnerReviews = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresCommitSignatures':
          result.requiresCommitSignatures = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresLinearHistory':
          result.requiresLinearHistory = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresStatusChecks':
          result.requiresStatusChecks = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'requiresStrictStatusChecks':
          result.requiresStrictStatusChecks = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'restrictsPushes':
          result.restrictsPushes = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'restrictsReviewDismissals':
          result.restrictsReviewDismissals = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'reviewDismissalActorIds':
          result.reviewDismissalActorIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateCheckRunInputSerializer
    implements StructuredSerializer<GUpdateCheckRunInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateCheckRunInput,
    _$GUpdateCheckRunInput
  ];
  @override
  final String wireName = 'GUpdateCheckRunInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateCheckRunInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'checkRunId',
      serializers.serialize(object.checkRunId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.actions;
    if (value != null) {
      result
        ..add('actions')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(
                BuiltList, const [const FullType(GCheckRunAction)])));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.completedAt;
    if (value != null) {
      result
        ..add('completedAt')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(DateTime)));
    }
    value = object.conclusion;
    if (value != null) {
      result
        ..add('conclusion')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GCheckConclusionState)));
    }
    value = object.detailsUrl;
    if (value != null) {
      result
        ..add('detailsUrl')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.externalId;
    if (value != null) {
      result
        ..add('externalId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.name;
    if (value != null) {
      result
        ..add('name')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.output;
    if (value != null) {
      result
        ..add('output')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GCheckRunOutput)));
    }
    value = object.startedAt;
    if (value != null) {
      result
        ..add('startedAt')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(DateTime)));
    }
    value = object.status;
    if (value != null) {
      result
        ..add('status')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GRequestableCheckStatusState)));
    }
    return result;
  }

  @override
  GUpdateCheckRunInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateCheckRunInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'actions':
          result.actions.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(GCheckRunAction)]))!
              as BuiltList<Object>);
          break;
        case 'checkRunId':
          result.checkRunId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'completedAt':
          result.completedAt = serializers.deserialize(value,
              specifiedType: const FullType(DateTime)) as DateTime;
          break;
        case 'conclusion':
          result.conclusion = serializers.deserialize(value,
                  specifiedType: const FullType(GCheckConclusionState))
              as GCheckConclusionState;
          break;
        case 'detailsUrl':
          result.detailsUrl = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'externalId':
          result.externalId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'output':
          result.output.replace(serializers.deserialize(value,
                  specifiedType: const FullType(GCheckRunOutput))!
              as GCheckRunOutput);
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'startedAt':
          result.startedAt = serializers.deserialize(value,
              specifiedType: const FullType(DateTime)) as DateTime;
          break;
        case 'status':
          result.status = serializers.deserialize(value,
                  specifiedType: const FullType(GRequestableCheckStatusState))
              as GRequestableCheckStatusState;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateCheckSuitePreferencesInputSerializer
    implements StructuredSerializer<GUpdateCheckSuitePreferencesInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateCheckSuitePreferencesInput,
    _$GUpdateCheckSuitePreferencesInput
  ];
  @override
  final String wireName = 'GUpdateCheckSuitePreferencesInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateCheckSuitePreferencesInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'autoTriggerPreferences',
      serializers.serialize(object.autoTriggerPreferences,
          specifiedType: const FullType(BuiltList,
              const [const FullType(GCheckSuiteAutoTriggerPreference)])),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateCheckSuitePreferencesInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateCheckSuitePreferencesInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'autoTriggerPreferences':
          result.autoTriggerPreferences.replace(serializers.deserialize(value,
              specifiedType: const FullType(BuiltList, const [
                const FullType(GCheckSuiteAutoTriggerPreference)
              ]))! as BuiltList<Object>);
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateDiscussionCommentInputSerializer
    implements StructuredSerializer<GUpdateDiscussionCommentInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateDiscussionCommentInput,
    _$GUpdateDiscussionCommentInput
  ];
  @override
  final String wireName = 'GUpdateDiscussionCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateDiscussionCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'commentId',
      serializers.serialize(object.commentId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateDiscussionCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateDiscussionCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'commentId':
          result.commentId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateDiscussionInputSerializer
    implements StructuredSerializer<GUpdateDiscussionInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateDiscussionInput,
    _$GUpdateDiscussionInput
  ];
  @override
  final String wireName = 'GUpdateDiscussionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateDiscussionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'discussionId',
      serializers.serialize(object.discussionId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.categoryId;
    if (value != null) {
      result
        ..add('categoryId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.title;
    if (value != null) {
      result
        ..add('title')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateDiscussionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateDiscussionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'categoryId':
          result.categoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'discussionId':
          result.discussionId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseAdministratorRoleInputSerializer
    implements StructuredSerializer<GUpdateEnterpriseAdministratorRoleInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseAdministratorRoleInput,
    _$GUpdateEnterpriseAdministratorRoleInput
  ];
  @override
  final String wireName = 'GUpdateEnterpriseAdministratorRoleInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateEnterpriseAdministratorRoleInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'login',
      serializers.serialize(object.login,
          specifiedType: const FullType(String)),
      'role',
      serializers.serialize(object.role,
          specifiedType: const FullType(GEnterpriseAdministratorRole)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseAdministratorRoleInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateEnterpriseAdministratorRoleInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'login':
          result.login = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'role':
          result.role = serializers.deserialize(value,
                  specifiedType: const FullType(GEnterpriseAdministratorRole))
              as GEnterpriseAdministratorRole;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput,
    _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseDefaultRepositoryPermissionSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseDefaultRepositoryPermissionSettingInput,
    _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseDefaultRepositoryPermissionSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseDefaultRepositoryPermissionSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType: const FullType(
              GEnterpriseDefaultRepositoryPermissionSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseDefaultRepositoryPermissionSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType: const FullType(
                      GEnterpriseDefaultRepositoryPermissionSettingValue))
              as GEnterpriseDefaultRepositoryPermissionSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput,
    _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput,
    _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.membersCanCreateInternalRepositories;
    if (value != null) {
      result
        ..add('membersCanCreateInternalRepositories')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.membersCanCreatePrivateRepositories;
    if (value != null) {
      result
        ..add('membersCanCreatePrivateRepositories')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.membersCanCreatePublicRepositories;
    if (value != null) {
      result
        ..add('membersCanCreatePublicRepositories')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.membersCanCreateRepositoriesPolicyEnabled;
    if (value != null) {
      result
        ..add('membersCanCreateRepositoriesPolicyEnabled')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.settingValue;
    if (value != null) {
      result
        ..add('settingValue')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(
                GEnterpriseMembersCanCreateRepositoriesSettingValue)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'membersCanCreateInternalRepositories':
          result.membersCanCreateInternalRepositories = serializers
              .deserialize(value, specifiedType: const FullType(bool)) as bool;
          break;
        case 'membersCanCreatePrivateRepositories':
          result.membersCanCreatePrivateRepositories = serializers
              .deserialize(value, specifiedType: const FullType(bool)) as bool;
          break;
        case 'membersCanCreatePublicRepositories':
          result.membersCanCreatePublicRepositories = serializers
              .deserialize(value, specifiedType: const FullType(bool)) as bool;
          break;
        case 'membersCanCreateRepositoriesPolicyEnabled':
          result.membersCanCreateRepositoriesPolicyEnabled = serializers
              .deserialize(value, specifiedType: const FullType(bool)) as bool;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType: const FullType(
                      GEnterpriseMembersCanCreateRepositoriesSettingValue))
              as GEnterpriseMembersCanCreateRepositoriesSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanDeleteIssuesSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanDeleteIssuesSettingInput,
    _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput
  ];
  @override
  final String wireName = 'GUpdateEnterpriseMembersCanDeleteIssuesSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanDeleteIssuesSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanDeleteIssuesSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput,
    _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput,
    _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanMakePurchasesSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanMakePurchasesSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanMakePurchasesSettingInput,
    _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseMembersCanMakePurchasesSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanMakePurchasesSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseMembersCanMakePurchasesSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanMakePurchasesSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType: const FullType(
                      GEnterpriseMembersCanMakePurchasesSettingValue))
              as GEnterpriseMembersCanMakePurchasesSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput,
    _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput,
    _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseOrganizationProjectsSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseOrganizationProjectsSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseOrganizationProjectsSettingInput,
    _$GUpdateEnterpriseOrganizationProjectsSettingInput
  ];
  @override
  final String wireName = 'GUpdateEnterpriseOrganizationProjectsSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseOrganizationProjectsSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseOrganizationProjectsSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseOrganizationProjectsSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseProfileInputSerializer
    implements StructuredSerializer<GUpdateEnterpriseProfileInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseProfileInput,
    _$GUpdateEnterpriseProfileInput
  ];
  @override
  final String wireName = 'GUpdateEnterpriseProfileInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateEnterpriseProfileInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.description;
    if (value != null) {
      result
        ..add('description')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.location;
    if (value != null) {
      result
        ..add('location')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.name;
    if (value != null) {
      result
        ..add('name')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.websiteUrl;
    if (value != null) {
      result
        ..add('websiteUrl')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseProfileInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateEnterpriseProfileInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'description':
          result.description = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'location':
          result.location = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'websiteUrl':
          result.websiteUrl = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseRepositoryProjectsSettingInputSerializer
    implements
        StructuredSerializer<GUpdateEnterpriseRepositoryProjectsSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseRepositoryProjectsSettingInput,
    _$GUpdateEnterpriseRepositoryProjectsSettingInput
  ];
  @override
  final String wireName = 'GUpdateEnterpriseRepositoryProjectsSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseRepositoryProjectsSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseRepositoryProjectsSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateEnterpriseRepositoryProjectsSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseTeamDiscussionsSettingInputSerializer
    implements
        StructuredSerializer<GUpdateEnterpriseTeamDiscussionsSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseTeamDiscussionsSettingInput,
    _$GUpdateEnterpriseTeamDiscussionsSettingInput
  ];
  @override
  final String wireName = 'GUpdateEnterpriseTeamDiscussionsSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseTeamDiscussionsSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType:
              const FullType(GEnterpriseEnabledDisabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseTeamDiscussionsSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateEnterpriseTeamDiscussionsSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GEnterpriseEnabledDisabledSettingValue))
              as GEnterpriseEnabledDisabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputSerializer
    implements
        StructuredSerializer<
            GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput,
    _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput
  ];
  @override
  final String wireName =
      'GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'enterpriseId',
      serializers.serialize(object.enterpriseId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType: const FullType(GEnterpriseEnabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result =
        new GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'enterpriseId':
          result.enterpriseId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType: const FullType(GEnterpriseEnabledSettingValue))
              as GEnterpriseEnabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateEnvironmentInputSerializer
    implements StructuredSerializer<GUpdateEnvironmentInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateEnvironmentInput,
    _$GUpdateEnvironmentInput
  ];
  @override
  final String wireName = 'GUpdateEnvironmentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateEnvironmentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'environmentId',
      serializers.serialize(object.environmentId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.reviewers;
    if (value != null) {
      result
        ..add('reviewers')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.waitTimer;
    if (value != null) {
      result
        ..add('waitTimer')
        ..add(serializers.serialize(value, specifiedType: const FullType(int)));
    }
    return result;
  }

  @override
  GUpdateEnvironmentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateEnvironmentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'environmentId':
          result.environmentId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'reviewers':
          result.reviewers.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'waitTimer':
          result.waitTimer = serializers.deserialize(value,
              specifiedType: const FullType(int)) as int;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateIpAllowListEnabledSettingInputSerializer
    implements StructuredSerializer<GUpdateIpAllowListEnabledSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateIpAllowListEnabledSettingInput,
    _$GUpdateIpAllowListEnabledSettingInput
  ];
  @override
  final String wireName = 'GUpdateIpAllowListEnabledSettingInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateIpAllowListEnabledSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'ownerId',
      serializers.serialize(object.ownerId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType: const FullType(GIpAllowListEnabledSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateIpAllowListEnabledSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateIpAllowListEnabledSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ownerId':
          result.ownerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GIpAllowListEnabledSettingValue))
              as GIpAllowListEnabledSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateIpAllowListEntryInputSerializer
    implements StructuredSerializer<GUpdateIpAllowListEntryInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateIpAllowListEntryInput,
    _$GUpdateIpAllowListEntryInput
  ];
  @override
  final String wireName = 'GUpdateIpAllowListEntryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateIpAllowListEntryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'allowListValue',
      serializers.serialize(object.allowListValue,
          specifiedType: const FullType(String)),
      'ipAllowListEntryId',
      serializers.serialize(object.ipAllowListEntryId,
          specifiedType: const FullType(String)),
      'isActive',
      serializers.serialize(object.isActive,
          specifiedType: const FullType(bool)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.name;
    if (value != null) {
      result
        ..add('name')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateIpAllowListEntryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateIpAllowListEntryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'allowListValue':
          result.allowListValue = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ipAllowListEntryId':
          result.ipAllowListEntryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'isActive':
          result.isActive = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateIssueCommentInputSerializer
    implements StructuredSerializer<GUpdateIssueCommentInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateIssueCommentInput,
    _$GUpdateIssueCommentInput
  ];
  @override
  final String wireName = 'GUpdateIssueCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateIssueCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateIssueCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateIssueCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateIssueInputSerializer
    implements StructuredSerializer<GUpdateIssueInput> {
  @override
  final Iterable<Type> types = const [GUpdateIssueInput, _$GUpdateIssueInput];
  @override
  final String wireName = 'GUpdateIssueInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GUpdateIssueInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.assigneeIds;
    if (value != null) {
      result
        ..add('assigneeIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.labelIds;
    if (value != null) {
      result
        ..add('labelIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.milestoneId;
    if (value != null) {
      result
        ..add('milestoneId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.projectIds;
    if (value != null) {
      result
        ..add('projectIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.state;
    if (value != null) {
      result
        ..add('state')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GIssueState)));
    }
    value = object.title;
    if (value != null) {
      result
        ..add('title')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateIssueInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateIssueInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'assigneeIds':
          result.assigneeIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'labelIds':
          result.labelIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'milestoneId':
          result.milestoneId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectIds':
          result.projectIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'state':
          result.state = serializers.deserialize(value,
              specifiedType: const FullType(GIssueState)) as GIssueState;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateNotificationRestrictionSettingInputSerializer
    implements
        StructuredSerializer<GUpdateNotificationRestrictionSettingInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateNotificationRestrictionSettingInput,
    _$GUpdateNotificationRestrictionSettingInput
  ];
  @override
  final String wireName = 'GUpdateNotificationRestrictionSettingInput';

  @override
  Iterable<Object?> serialize(Serializers serializers,
      GUpdateNotificationRestrictionSettingInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'ownerId',
      serializers.serialize(object.ownerId,
          specifiedType: const FullType(String)),
      'settingValue',
      serializers.serialize(object.settingValue,
          specifiedType: const FullType(GNotificationRestrictionSettingValue)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateNotificationRestrictionSettingInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateNotificationRestrictionSettingInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'ownerId':
          result.ownerId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'settingValue':
          result.settingValue = serializers.deserialize(value,
                  specifiedType:
                      const FullType(GNotificationRestrictionSettingValue))
              as GNotificationRestrictionSettingValue;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateProjectCardInputSerializer
    implements StructuredSerializer<GUpdateProjectCardInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateProjectCardInput,
    _$GUpdateProjectCardInput
  ];
  @override
  final String wireName = 'GUpdateProjectCardInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateProjectCardInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'projectCardId',
      serializers.serialize(object.projectCardId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.isArchived;
    if (value != null) {
      result
        ..add('isArchived')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.note;
    if (value != null) {
      result
        ..add('note')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateProjectCardInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateProjectCardInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'isArchived':
          result.isArchived = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'note':
          result.note = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectCardId':
          result.projectCardId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateProjectColumnInputSerializer
    implements StructuredSerializer<GUpdateProjectColumnInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateProjectColumnInput,
    _$GUpdateProjectColumnInput
  ];
  @override
  final String wireName = 'GUpdateProjectColumnInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateProjectColumnInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'name',
      serializers.serialize(object.name, specifiedType: const FullType(String)),
      'projectColumnId',
      serializers.serialize(object.projectColumnId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateProjectColumnInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateProjectColumnInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectColumnId':
          result.projectColumnId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateProjectInputSerializer
    implements StructuredSerializer<GUpdateProjectInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateProjectInput,
    _$GUpdateProjectInput
  ];
  @override
  final String wireName = 'GUpdateProjectInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateProjectInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'projectId',
      serializers.serialize(object.projectId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.name;
    if (value != null) {
      result
        ..add('name')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.public;
    if (value != null) {
      result
        ..add('public')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.state;
    if (value != null) {
      result
        ..add('state')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GProjectState)));
    }
    return result;
  }

  @override
  GUpdateProjectInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateProjectInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectId':
          result.projectId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'public':
          result.public = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'state':
          result.state = serializers.deserialize(value,
              specifiedType: const FullType(GProjectState)) as GProjectState;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdatePullRequestInputSerializer
    implements StructuredSerializer<GUpdatePullRequestInput> {
  @override
  final Iterable<Type> types = const [
    GUpdatePullRequestInput,
    _$GUpdatePullRequestInput
  ];
  @override
  final String wireName = 'GUpdatePullRequestInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdatePullRequestInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.assigneeIds;
    if (value != null) {
      result
        ..add('assigneeIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.baseRefName;
    if (value != null) {
      result
        ..add('baseRefName')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.labelIds;
    if (value != null) {
      result
        ..add('labelIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.maintainerCanModify;
    if (value != null) {
      result
        ..add('maintainerCanModify')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.milestoneId;
    if (value != null) {
      result
        ..add('milestoneId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.projectIds;
    if (value != null) {
      result
        ..add('projectIds')
        ..add(serializers.serialize(value,
            specifiedType:
                const FullType(BuiltList, const [const FullType(String)])));
    }
    value = object.state;
    if (value != null) {
      result
        ..add('state')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(GPullRequestUpdateState)));
    }
    value = object.title;
    if (value != null) {
      result
        ..add('title')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdatePullRequestInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdatePullRequestInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'assigneeIds':
          result.assigneeIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'baseRefName':
          result.baseRefName = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'labelIds':
          result.labelIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'maintainerCanModify':
          result.maintainerCanModify = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'milestoneId':
          result.milestoneId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'projectIds':
          result.projectIds.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
        case 'pullRequestId':
          result.pullRequestId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'state':
          result.state = serializers.deserialize(value,
                  specifiedType: const FullType(GPullRequestUpdateState))
              as GPullRequestUpdateState;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdatePullRequestReviewCommentInputSerializer
    implements StructuredSerializer<GUpdatePullRequestReviewCommentInput> {
  @override
  final Iterable<Type> types = const [
    GUpdatePullRequestReviewCommentInput,
    _$GUpdatePullRequestReviewCommentInput
  ];
  @override
  final String wireName = 'GUpdatePullRequestReviewCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdatePullRequestReviewCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'pullRequestReviewCommentId',
      serializers.serialize(object.pullRequestReviewCommentId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdatePullRequestReviewCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdatePullRequestReviewCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestReviewCommentId':
          result.pullRequestReviewCommentId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdatePullRequestReviewInputSerializer
    implements StructuredSerializer<GUpdatePullRequestReviewInput> {
  @override
  final Iterable<Type> types = const [
    GUpdatePullRequestReviewInput,
    _$GUpdatePullRequestReviewInput
  ];
  @override
  final String wireName = 'GUpdatePullRequestReviewInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdatePullRequestReviewInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'pullRequestReviewId',
      serializers.serialize(object.pullRequestReviewId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdatePullRequestReviewInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdatePullRequestReviewInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pullRequestReviewId':
          result.pullRequestReviewId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateRefInputSerializer
    implements StructuredSerializer<GUpdateRefInput> {
  @override
  final Iterable<Type> types = const [GUpdateRefInput, _$GUpdateRefInput];
  @override
  final String wireName = 'GUpdateRefInput';

  @override
  Iterable<Object?> serialize(Serializers serializers, GUpdateRefInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'oid',
      serializers.serialize(object.oid, specifiedType: const FullType(String)),
      'refId',
      serializers.serialize(object.refId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.force;
    if (value != null) {
      result
        ..add('force')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GUpdateRefInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateRefInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'force':
          result.force = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'oid':
          result.oid = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'refId':
          result.refId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateRepositoryInputSerializer
    implements StructuredSerializer<GUpdateRepositoryInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateRepositoryInput,
    _$GUpdateRepositoryInput
  ];
  @override
  final String wireName = 'GUpdateRepositoryInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateRepositoryInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.description;
    if (value != null) {
      result
        ..add('description')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.hasIssuesEnabled;
    if (value != null) {
      result
        ..add('hasIssuesEnabled')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.hasProjectsEnabled;
    if (value != null) {
      result
        ..add('hasProjectsEnabled')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.hasWikiEnabled;
    if (value != null) {
      result
        ..add('hasWikiEnabled')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.homepageUrl;
    if (value != null) {
      result
        ..add('homepageUrl')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.name;
    if (value != null) {
      result
        ..add('name')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.template;
    if (value != null) {
      result
        ..add('template')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    return result;
  }

  @override
  GUpdateRepositoryInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateRepositoryInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'description':
          result.description = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'hasIssuesEnabled':
          result.hasIssuesEnabled = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'hasProjectsEnabled':
          result.hasProjectsEnabled = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'hasWikiEnabled':
          result.hasWikiEnabled = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'homepageUrl':
          result.homepageUrl = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'name':
          result.name = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'template':
          result.template = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateSubscriptionInputSerializer
    implements StructuredSerializer<GUpdateSubscriptionInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateSubscriptionInput,
    _$GUpdateSubscriptionInput
  ];
  @override
  final String wireName = 'GUpdateSubscriptionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateSubscriptionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'state',
      serializers.serialize(object.state,
          specifiedType: const FullType(GSubscriptionState)),
      'subscribableId',
      serializers.serialize(object.subscribableId,
          specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateSubscriptionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateSubscriptionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'state':
          result.state = serializers.deserialize(value,
                  specifiedType: const FullType(GSubscriptionState))
              as GSubscriptionState;
          break;
        case 'subscribableId':
          result.subscribableId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateTeamDiscussionCommentInputSerializer
    implements StructuredSerializer<GUpdateTeamDiscussionCommentInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateTeamDiscussionCommentInput,
    _$GUpdateTeamDiscussionCommentInput
  ];
  @override
  final String wireName = 'GUpdateTeamDiscussionCommentInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateTeamDiscussionCommentInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'body',
      serializers.serialize(object.body, specifiedType: const FullType(String)),
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.bodyVersion;
    if (value != null) {
      result
        ..add('bodyVersion')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateTeamDiscussionCommentInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateTeamDiscussionCommentInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'bodyVersion':
          result.bodyVersion = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateTeamDiscussionInputSerializer
    implements StructuredSerializer<GUpdateTeamDiscussionInput> {
  @override
  final Iterable<Type> types = const [
    GUpdateTeamDiscussionInput,
    _$GUpdateTeamDiscussionInput
  ];
  @override
  final String wireName = 'GUpdateTeamDiscussionInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateTeamDiscussionInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.body;
    if (value != null) {
      result
        ..add('body')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.bodyVersion;
    if (value != null) {
      result
        ..add('bodyVersion')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    value = object.pinned;
    if (value != null) {
      result
        ..add('pinned')
        ..add(
            serializers.serialize(value, specifiedType: const FullType(bool)));
    }
    value = object.title;
    if (value != null) {
      result
        ..add('title')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateTeamDiscussionInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateTeamDiscussionInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'body':
          result.body = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'bodyVersion':
          result.bodyVersion = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'pinned':
          result.pinned = serializers.deserialize(value,
              specifiedType: const FullType(bool)) as bool;
          break;
        case 'title':
          result.title = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GUpdateTopicsInputSerializer
    implements StructuredSerializer<GUpdateTopicsInput> {
  @override
  final Iterable<Type> types = const [GUpdateTopicsInput, _$GUpdateTopicsInput];
  @override
  final String wireName = 'GUpdateTopicsInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GUpdateTopicsInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
      'topicNames',
      serializers.serialize(object.topicNames,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GUpdateTopicsInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUpdateTopicsInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'repositoryId':
          result.repositoryId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'topicNames':
          result.topicNames.replace(serializers.deserialize(value,
                  specifiedType: const FullType(
                      BuiltList, const [const FullType(String)]))!
              as BuiltList<Object>);
          break;
      }
    }

    return result.build();
  }
}

class _$GUserBlockDurationSerializer
    implements PrimitiveSerializer<GUserBlockDuration> {
  @override
  final Iterable<Type> types = const <Type>[GUserBlockDuration];
  @override
  final String wireName = 'GUserBlockDuration';

  @override
  Object serialize(Serializers serializers, GUserBlockDuration object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GUserBlockDuration deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GUserBlockDuration.valueOf(serialized as String);
}

class _$GUserStatusOrderSerializer
    implements StructuredSerializer<GUserStatusOrder> {
  @override
  final Iterable<Type> types = const [GUserStatusOrder, _$GUserStatusOrder];
  @override
  final String wireName = 'GUserStatusOrder';

  @override
  Iterable<Object?> serialize(Serializers serializers, GUserStatusOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GUserStatusOrderField)),
    ];

    return result;
  }

  @override
  GUserStatusOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GUserStatusOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GUserStatusOrderField))
              as GUserStatusOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GUserStatusOrderFieldSerializer
    implements PrimitiveSerializer<GUserStatusOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GUserStatusOrderField];
  @override
  final String wireName = 'GUserStatusOrderField';

  @override
  Object serialize(Serializers serializers, GUserStatusOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GUserStatusOrderField deserialize(Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GUserStatusOrderField.valueOf(serialized as String);
}

class _$GVerifiableDomainOrderSerializer
    implements StructuredSerializer<GVerifiableDomainOrder> {
  @override
  final Iterable<Type> types = const [
    GVerifiableDomainOrder,
    _$GVerifiableDomainOrder
  ];
  @override
  final String wireName = 'GVerifiableDomainOrder';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GVerifiableDomainOrder object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'direction',
      serializers.serialize(object.direction,
          specifiedType: const FullType(GOrderDirection)),
      'field',
      serializers.serialize(object.field,
          specifiedType: const FullType(GVerifiableDomainOrderField)),
    ];

    return result;
  }

  @override
  GVerifiableDomainOrder deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GVerifiableDomainOrderBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'direction':
          result.direction = serializers.deserialize(value,
                  specifiedType: const FullType(GOrderDirection))
              as GOrderDirection;
          break;
        case 'field':
          result.field = serializers.deserialize(value,
                  specifiedType: const FullType(GVerifiableDomainOrderField))
              as GVerifiableDomainOrderField;
          break;
      }
    }

    return result.build();
  }
}

class _$GVerifiableDomainOrderFieldSerializer
    implements PrimitiveSerializer<GVerifiableDomainOrderField> {
  @override
  final Iterable<Type> types = const <Type>[GVerifiableDomainOrderField];
  @override
  final String wireName = 'GVerifiableDomainOrderField';

  @override
  Object serialize(Serializers serializers, GVerifiableDomainOrderField object,
          {FullType specifiedType = FullType.unspecified}) =>
      object.name;

  @override
  GVerifiableDomainOrderField deserialize(
          Serializers serializers, Object serialized,
          {FullType specifiedType = FullType.unspecified}) =>
      GVerifiableDomainOrderField.valueOf(serialized as String);
}

class _$GVerifyVerifiableDomainInputSerializer
    implements StructuredSerializer<GVerifyVerifiableDomainInput> {
  @override
  final Iterable<Type> types = const [
    GVerifyVerifiableDomainInput,
    _$GVerifyVerifiableDomainInput
  ];
  @override
  final String wireName = 'GVerifyVerifiableDomainInput';

  @override
  Iterable<Object?> serialize(
      Serializers serializers, GVerifyVerifiableDomainInput object,
      {FullType specifiedType = FullType.unspecified}) {
    final result = <Object?>[
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
    ];
    Object? value;
    value = object.clientMutationId;
    if (value != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(value,
            specifiedType: const FullType(String)));
    }
    return result;
  }

  @override
  GVerifyVerifiableDomainInput deserialize(
      Serializers serializers, Iterable<Object?> serialized,
      {FullType specifiedType = FullType.unspecified}) {
    final result = new GVerifyVerifiableDomainInputBuilder();

    final iterator = serialized.iterator;
    while (iterator.moveNext()) {
      final key = iterator.current as String;
      iterator.moveNext();
      final Object? value = iterator.current;
      switch (key) {
        case 'clientMutationId':
          result.clientMutationId = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
        case 'id':
          result.id = serializers.deserialize(value,
              specifiedType: const FullType(String)) as String;
          break;
      }
    }

    return result.build();
  }
}

class _$GAcceptEnterpriseAdministratorInvitationInput
    extends GAcceptEnterpriseAdministratorInvitationInput {
  @override
  final String? clientMutationId;
  @override
  final String invitationId;

  factory _$GAcceptEnterpriseAdministratorInvitationInput(
          [void Function(GAcceptEnterpriseAdministratorInvitationInputBuilder)?
              updates]) =>
      (new GAcceptEnterpriseAdministratorInvitationInputBuilder()
            ..update(updates))
          .build();

  _$GAcceptEnterpriseAdministratorInvitationInput._(
      {this.clientMutationId, required this.invitationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(invitationId,
        'GAcceptEnterpriseAdministratorInvitationInput', 'invitationId');
  }

  @override
  GAcceptEnterpriseAdministratorInvitationInput rebuild(
          void Function(GAcceptEnterpriseAdministratorInvitationInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAcceptEnterpriseAdministratorInvitationInputBuilder toBuilder() =>
      new GAcceptEnterpriseAdministratorInvitationInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAcceptEnterpriseAdministratorInvitationInput &&
        clientMutationId == other.clientMutationId &&
        invitationId == other.invitationId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), invitationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GAcceptEnterpriseAdministratorInvitationInput')
          ..add('clientMutationId', clientMutationId)
          ..add('invitationId', invitationId))
        .toString();
  }
}

class GAcceptEnterpriseAdministratorInvitationInputBuilder
    implements
        Builder<GAcceptEnterpriseAdministratorInvitationInput,
            GAcceptEnterpriseAdministratorInvitationInputBuilder> {
  _$GAcceptEnterpriseAdministratorInvitationInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _invitationId;
  String? get invitationId => _$this._invitationId;
  set invitationId(String? invitationId) => _$this._invitationId = invitationId;

  GAcceptEnterpriseAdministratorInvitationInputBuilder();

  GAcceptEnterpriseAdministratorInvitationInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _invitationId = $v.invitationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAcceptEnterpriseAdministratorInvitationInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAcceptEnterpriseAdministratorInvitationInput;
  }

  @override
  void update(
      void Function(GAcceptEnterpriseAdministratorInvitationInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAcceptEnterpriseAdministratorInvitationInput build() {
    final _$result = _$v ??
        new _$GAcceptEnterpriseAdministratorInvitationInput._(
            clientMutationId: clientMutationId,
            invitationId: BuiltValueNullFieldError.checkNotNull(
                invitationId,
                'GAcceptEnterpriseAdministratorInvitationInput',
                'invitationId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAcceptTopicSuggestionInput extends GAcceptTopicSuggestionInput {
  @override
  final String? clientMutationId;
  @override
  final String name;
  @override
  final String repositoryId;

  factory _$GAcceptTopicSuggestionInput(
          [void Function(GAcceptTopicSuggestionInputBuilder)? updates]) =>
      (new GAcceptTopicSuggestionInputBuilder()..update(updates)).build();

  _$GAcceptTopicSuggestionInput._(
      {this.clientMutationId, required this.name, required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        name, 'GAcceptTopicSuggestionInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GAcceptTopicSuggestionInput', 'repositoryId');
  }

  @override
  GAcceptTopicSuggestionInput rebuild(
          void Function(GAcceptTopicSuggestionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAcceptTopicSuggestionInputBuilder toBuilder() =>
      new GAcceptTopicSuggestionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAcceptTopicSuggestionInput &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), name.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAcceptTopicSuggestionInput')
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GAcceptTopicSuggestionInputBuilder
    implements
        Builder<GAcceptTopicSuggestionInput,
            GAcceptTopicSuggestionInputBuilder> {
  _$GAcceptTopicSuggestionInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GAcceptTopicSuggestionInputBuilder();

  GAcceptTopicSuggestionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAcceptTopicSuggestionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAcceptTopicSuggestionInput;
  }

  @override
  void update(void Function(GAcceptTopicSuggestionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAcceptTopicSuggestionInput build() {
    final _$result = _$v ??
        new _$GAcceptTopicSuggestionInput._(
            clientMutationId: clientMutationId,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GAcceptTopicSuggestionInput', 'name'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GAcceptTopicSuggestionInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddAssigneesToAssignableInput extends GAddAssigneesToAssignableInput {
  @override
  final String assignableId;
  @override
  final BuiltList<String> assigneeIds;
  @override
  final String? clientMutationId;

  factory _$GAddAssigneesToAssignableInput(
          [void Function(GAddAssigneesToAssignableInputBuilder)? updates]) =>
      (new GAddAssigneesToAssignableInputBuilder()..update(updates)).build();

  _$GAddAssigneesToAssignableInput._(
      {required this.assignableId,
      required this.assigneeIds,
      this.clientMutationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        assignableId, 'GAddAssigneesToAssignableInput', 'assignableId');
    BuiltValueNullFieldError.checkNotNull(
        assigneeIds, 'GAddAssigneesToAssignableInput', 'assigneeIds');
  }

  @override
  GAddAssigneesToAssignableInput rebuild(
          void Function(GAddAssigneesToAssignableInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddAssigneesToAssignableInputBuilder toBuilder() =>
      new GAddAssigneesToAssignableInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddAssigneesToAssignableInput &&
        assignableId == other.assignableId &&
        assigneeIds == other.assigneeIds &&
        clientMutationId == other.clientMutationId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, assignableId.hashCode), assigneeIds.hashCode),
        clientMutationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddAssigneesToAssignableInput')
          ..add('assignableId', assignableId)
          ..add('assigneeIds', assigneeIds)
          ..add('clientMutationId', clientMutationId))
        .toString();
  }
}

class GAddAssigneesToAssignableInputBuilder
    implements
        Builder<GAddAssigneesToAssignableInput,
            GAddAssigneesToAssignableInputBuilder> {
  _$GAddAssigneesToAssignableInput? _$v;

  String? _assignableId;
  String? get assignableId => _$this._assignableId;
  set assignableId(String? assignableId) => _$this._assignableId = assignableId;

  ListBuilder<String>? _assigneeIds;
  ListBuilder<String> get assigneeIds =>
      _$this._assigneeIds ??= new ListBuilder<String>();
  set assigneeIds(ListBuilder<String>? assigneeIds) =>
      _$this._assigneeIds = assigneeIds;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GAddAssigneesToAssignableInputBuilder();

  GAddAssigneesToAssignableInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _assignableId = $v.assignableId;
      _assigneeIds = $v.assigneeIds.toBuilder();
      _clientMutationId = $v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddAssigneesToAssignableInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddAssigneesToAssignableInput;
  }

  @override
  void update(void Function(GAddAssigneesToAssignableInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddAssigneesToAssignableInput build() {
    _$GAddAssigneesToAssignableInput _$result;
    try {
      _$result = _$v ??
          new _$GAddAssigneesToAssignableInput._(
              assignableId: BuiltValueNullFieldError.checkNotNull(assignableId,
                  'GAddAssigneesToAssignableInput', 'assignableId'),
              assigneeIds: assigneeIds.build(),
              clientMutationId: clientMutationId);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'assigneeIds';
        assigneeIds.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GAddAssigneesToAssignableInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GAddCommentInput extends GAddCommentInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String subjectId;

  factory _$GAddCommentInput(
          [void Function(GAddCommentInputBuilder)? updates]) =>
      (new GAddCommentInputBuilder()..update(updates)).build();

  _$GAddCommentInput._(
      {required this.body, this.clientMutationId, required this.subjectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(body, 'GAddCommentInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        subjectId, 'GAddCommentInput', 'subjectId');
  }

  @override
  GAddCommentInput rebuild(void Function(GAddCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddCommentInputBuilder toBuilder() =>
      new GAddCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddCommentInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        subjectId == other.subjectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
        subjectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddCommentInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('subjectId', subjectId))
        .toString();
  }
}

class GAddCommentInputBuilder
    implements Builder<GAddCommentInput, GAddCommentInputBuilder> {
  _$GAddCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _subjectId;
  String? get subjectId => _$this._subjectId;
  set subjectId(String? subjectId) => _$this._subjectId = subjectId;

  GAddCommentInputBuilder();

  GAddCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _subjectId = $v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddCommentInput;
  }

  @override
  void update(void Function(GAddCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddCommentInput build() {
    final _$result = _$v ??
        new _$GAddCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GAddCommentInput', 'body'),
            clientMutationId: clientMutationId,
            subjectId: BuiltValueNullFieldError.checkNotNull(
                subjectId, 'GAddCommentInput', 'subjectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddDiscussionCommentInput extends GAddDiscussionCommentInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String discussionId;
  @override
  final String? replyToId;

  factory _$GAddDiscussionCommentInput(
          [void Function(GAddDiscussionCommentInputBuilder)? updates]) =>
      (new GAddDiscussionCommentInputBuilder()..update(updates)).build();

  _$GAddDiscussionCommentInput._(
      {required this.body,
      this.clientMutationId,
      required this.discussionId,
      this.replyToId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GAddDiscussionCommentInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        discussionId, 'GAddDiscussionCommentInput', 'discussionId');
  }

  @override
  GAddDiscussionCommentInput rebuild(
          void Function(GAddDiscussionCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddDiscussionCommentInputBuilder toBuilder() =>
      new GAddDiscussionCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddDiscussionCommentInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        discussionId == other.discussionId &&
        replyToId == other.replyToId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
            discussionId.hashCode),
        replyToId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddDiscussionCommentInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('discussionId', discussionId)
          ..add('replyToId', replyToId))
        .toString();
  }
}

class GAddDiscussionCommentInputBuilder
    implements
        Builder<GAddDiscussionCommentInput, GAddDiscussionCommentInputBuilder> {
  _$GAddDiscussionCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _discussionId;
  String? get discussionId => _$this._discussionId;
  set discussionId(String? discussionId) => _$this._discussionId = discussionId;

  String? _replyToId;
  String? get replyToId => _$this._replyToId;
  set replyToId(String? replyToId) => _$this._replyToId = replyToId;

  GAddDiscussionCommentInputBuilder();

  GAddDiscussionCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _discussionId = $v.discussionId;
      _replyToId = $v.replyToId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddDiscussionCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddDiscussionCommentInput;
  }

  @override
  void update(void Function(GAddDiscussionCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddDiscussionCommentInput build() {
    final _$result = _$v ??
        new _$GAddDiscussionCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GAddDiscussionCommentInput', 'body'),
            clientMutationId: clientMutationId,
            discussionId: BuiltValueNullFieldError.checkNotNull(
                discussionId, 'GAddDiscussionCommentInput', 'discussionId'),
            replyToId: replyToId);
    replace(_$result);
    return _$result;
  }
}

class _$GAddEnterpriseSupportEntitlementInput
    extends GAddEnterpriseSupportEntitlementInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final String login;

  factory _$GAddEnterpriseSupportEntitlementInput(
          [void Function(GAddEnterpriseSupportEntitlementInputBuilder)?
              updates]) =>
      (new GAddEnterpriseSupportEntitlementInputBuilder()..update(updates))
          .build();

  _$GAddEnterpriseSupportEntitlementInput._(
      {this.clientMutationId, required this.enterpriseId, required this.login})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GAddEnterpriseSupportEntitlementInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        login, 'GAddEnterpriseSupportEntitlementInput', 'login');
  }

  @override
  GAddEnterpriseSupportEntitlementInput rebuild(
          void Function(GAddEnterpriseSupportEntitlementInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddEnterpriseSupportEntitlementInputBuilder toBuilder() =>
      new GAddEnterpriseSupportEntitlementInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddEnterpriseSupportEntitlementInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        login == other.login;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        login.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddEnterpriseSupportEntitlementInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('login', login))
        .toString();
  }
}

class GAddEnterpriseSupportEntitlementInputBuilder
    implements
        Builder<GAddEnterpriseSupportEntitlementInput,
            GAddEnterpriseSupportEntitlementInputBuilder> {
  _$GAddEnterpriseSupportEntitlementInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _login;
  String? get login => _$this._login;
  set login(String? login) => _$this._login = login;

  GAddEnterpriseSupportEntitlementInputBuilder();

  GAddEnterpriseSupportEntitlementInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _login = $v.login;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddEnterpriseSupportEntitlementInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddEnterpriseSupportEntitlementInput;
  }

  @override
  void update(
      void Function(GAddEnterpriseSupportEntitlementInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddEnterpriseSupportEntitlementInput build() {
    final _$result = _$v ??
        new _$GAddEnterpriseSupportEntitlementInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                'GAddEnterpriseSupportEntitlementInput', 'enterpriseId'),
            login: BuiltValueNullFieldError.checkNotNull(
                login, 'GAddEnterpriseSupportEntitlementInput', 'login'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddLabelsToLabelableInput extends GAddLabelsToLabelableInput {
  @override
  final String? clientMutationId;
  @override
  final BuiltList<String> labelIds;
  @override
  final String labelableId;

  factory _$GAddLabelsToLabelableInput(
          [void Function(GAddLabelsToLabelableInputBuilder)? updates]) =>
      (new GAddLabelsToLabelableInputBuilder()..update(updates)).build();

  _$GAddLabelsToLabelableInput._(
      {this.clientMutationId,
      required this.labelIds,
      required this.labelableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        labelIds, 'GAddLabelsToLabelableInput', 'labelIds');
    BuiltValueNullFieldError.checkNotNull(
        labelableId, 'GAddLabelsToLabelableInput', 'labelableId');
  }

  @override
  GAddLabelsToLabelableInput rebuild(
          void Function(GAddLabelsToLabelableInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddLabelsToLabelableInputBuilder toBuilder() =>
      new GAddLabelsToLabelableInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddLabelsToLabelableInput &&
        clientMutationId == other.clientMutationId &&
        labelIds == other.labelIds &&
        labelableId == other.labelableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), labelIds.hashCode),
        labelableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddLabelsToLabelableInput')
          ..add('clientMutationId', clientMutationId)
          ..add('labelIds', labelIds)
          ..add('labelableId', labelableId))
        .toString();
  }
}

class GAddLabelsToLabelableInputBuilder
    implements
        Builder<GAddLabelsToLabelableInput, GAddLabelsToLabelableInputBuilder> {
  _$GAddLabelsToLabelableInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  ListBuilder<String>? _labelIds;
  ListBuilder<String> get labelIds =>
      _$this._labelIds ??= new ListBuilder<String>();
  set labelIds(ListBuilder<String>? labelIds) => _$this._labelIds = labelIds;

  String? _labelableId;
  String? get labelableId => _$this._labelableId;
  set labelableId(String? labelableId) => _$this._labelableId = labelableId;

  GAddLabelsToLabelableInputBuilder();

  GAddLabelsToLabelableInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _labelIds = $v.labelIds.toBuilder();
      _labelableId = $v.labelableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddLabelsToLabelableInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddLabelsToLabelableInput;
  }

  @override
  void update(void Function(GAddLabelsToLabelableInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddLabelsToLabelableInput build() {
    _$GAddLabelsToLabelableInput _$result;
    try {
      _$result = _$v ??
          new _$GAddLabelsToLabelableInput._(
              clientMutationId: clientMutationId,
              labelIds: labelIds.build(),
              labelableId: BuiltValueNullFieldError.checkNotNull(
                  labelableId, 'GAddLabelsToLabelableInput', 'labelableId'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'labelIds';
        labelIds.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GAddLabelsToLabelableInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GAddProjectCardInput extends GAddProjectCardInput {
  @override
  final String? clientMutationId;
  @override
  final String? contentId;
  @override
  final String? note;
  @override
  final String projectColumnId;

  factory _$GAddProjectCardInput(
          [void Function(GAddProjectCardInputBuilder)? updates]) =>
      (new GAddProjectCardInputBuilder()..update(updates)).build();

  _$GAddProjectCardInput._(
      {this.clientMutationId,
      this.contentId,
      this.note,
      required this.projectColumnId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        projectColumnId, 'GAddProjectCardInput', 'projectColumnId');
  }

  @override
  GAddProjectCardInput rebuild(
          void Function(GAddProjectCardInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddProjectCardInputBuilder toBuilder() =>
      new GAddProjectCardInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddProjectCardInput &&
        clientMutationId == other.clientMutationId &&
        contentId == other.contentId &&
        note == other.note &&
        projectColumnId == other.projectColumnId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), contentId.hashCode),
            note.hashCode),
        projectColumnId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddProjectCardInput')
          ..add('clientMutationId', clientMutationId)
          ..add('contentId', contentId)
          ..add('note', note)
          ..add('projectColumnId', projectColumnId))
        .toString();
  }
}

class GAddProjectCardInputBuilder
    implements Builder<GAddProjectCardInput, GAddProjectCardInputBuilder> {
  _$GAddProjectCardInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _contentId;
  String? get contentId => _$this._contentId;
  set contentId(String? contentId) => _$this._contentId = contentId;

  String? _note;
  String? get note => _$this._note;
  set note(String? note) => _$this._note = note;

  String? _projectColumnId;
  String? get projectColumnId => _$this._projectColumnId;
  set projectColumnId(String? projectColumnId) =>
      _$this._projectColumnId = projectColumnId;

  GAddProjectCardInputBuilder();

  GAddProjectCardInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _contentId = $v.contentId;
      _note = $v.note;
      _projectColumnId = $v.projectColumnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddProjectCardInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddProjectCardInput;
  }

  @override
  void update(void Function(GAddProjectCardInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddProjectCardInput build() {
    final _$result = _$v ??
        new _$GAddProjectCardInput._(
            clientMutationId: clientMutationId,
            contentId: contentId,
            note: note,
            projectColumnId: BuiltValueNullFieldError.checkNotNull(
                projectColumnId, 'GAddProjectCardInput', 'projectColumnId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddProjectColumnInput extends GAddProjectColumnInput {
  @override
  final String? clientMutationId;
  @override
  final String name;
  @override
  final String projectId;

  factory _$GAddProjectColumnInput(
          [void Function(GAddProjectColumnInputBuilder)? updates]) =>
      (new GAddProjectColumnInputBuilder()..update(updates)).build();

  _$GAddProjectColumnInput._(
      {this.clientMutationId, required this.name, required this.projectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        name, 'GAddProjectColumnInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        projectId, 'GAddProjectColumnInput', 'projectId');
  }

  @override
  GAddProjectColumnInput rebuild(
          void Function(GAddProjectColumnInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddProjectColumnInputBuilder toBuilder() =>
      new GAddProjectColumnInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddProjectColumnInput &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        projectId == other.projectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), name.hashCode),
        projectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddProjectColumnInput')
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('projectId', projectId))
        .toString();
  }
}

class GAddProjectColumnInputBuilder
    implements Builder<GAddProjectColumnInput, GAddProjectColumnInputBuilder> {
  _$GAddProjectColumnInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _projectId;
  String? get projectId => _$this._projectId;
  set projectId(String? projectId) => _$this._projectId = projectId;

  GAddProjectColumnInputBuilder();

  GAddProjectColumnInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _projectId = $v.projectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddProjectColumnInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddProjectColumnInput;
  }

  @override
  void update(void Function(GAddProjectColumnInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddProjectColumnInput build() {
    final _$result = _$v ??
        new _$GAddProjectColumnInput._(
            clientMutationId: clientMutationId,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GAddProjectColumnInput', 'name'),
            projectId: BuiltValueNullFieldError.checkNotNull(
                projectId, 'GAddProjectColumnInput', 'projectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddPullRequestReviewCommentInput
    extends GAddPullRequestReviewCommentInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String? commitOID;
  @override
  final String? inReplyTo;
  @override
  final String? path;
  @override
  final int? position;
  @override
  final String? pullRequestId;
  @override
  final String? pullRequestReviewId;

  factory _$GAddPullRequestReviewCommentInput(
          [void Function(GAddPullRequestReviewCommentInputBuilder)? updates]) =>
      (new GAddPullRequestReviewCommentInputBuilder()..update(updates)).build();

  _$GAddPullRequestReviewCommentInput._(
      {required this.body,
      this.clientMutationId,
      this.commitOID,
      this.inReplyTo,
      this.path,
      this.position,
      this.pullRequestId,
      this.pullRequestReviewId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GAddPullRequestReviewCommentInput', 'body');
  }

  @override
  GAddPullRequestReviewCommentInput rebuild(
          void Function(GAddPullRequestReviewCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddPullRequestReviewCommentInputBuilder toBuilder() =>
      new GAddPullRequestReviewCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddPullRequestReviewCommentInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        commitOID == other.commitOID &&
        inReplyTo == other.inReplyTo &&
        path == other.path &&
        position == other.position &&
        pullRequestId == other.pullRequestId &&
        pullRequestReviewId == other.pullRequestReviewId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc($jc(0, body.hashCode),
                                clientMutationId.hashCode),
                            commitOID.hashCode),
                        inReplyTo.hashCode),
                    path.hashCode),
                position.hashCode),
            pullRequestId.hashCode),
        pullRequestReviewId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddPullRequestReviewCommentInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('commitOID', commitOID)
          ..add('inReplyTo', inReplyTo)
          ..add('path', path)
          ..add('position', position)
          ..add('pullRequestId', pullRequestId)
          ..add('pullRequestReviewId', pullRequestReviewId))
        .toString();
  }
}

class GAddPullRequestReviewCommentInputBuilder
    implements
        Builder<GAddPullRequestReviewCommentInput,
            GAddPullRequestReviewCommentInputBuilder> {
  _$GAddPullRequestReviewCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _commitOID;
  String? get commitOID => _$this._commitOID;
  set commitOID(String? commitOID) => _$this._commitOID = commitOID;

  String? _inReplyTo;
  String? get inReplyTo => _$this._inReplyTo;
  set inReplyTo(String? inReplyTo) => _$this._inReplyTo = inReplyTo;

  String? _path;
  String? get path => _$this._path;
  set path(String? path) => _$this._path = path;

  int? _position;
  int? get position => _$this._position;
  set position(int? position) => _$this._position = position;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  String? _pullRequestReviewId;
  String? get pullRequestReviewId => _$this._pullRequestReviewId;
  set pullRequestReviewId(String? pullRequestReviewId) =>
      _$this._pullRequestReviewId = pullRequestReviewId;

  GAddPullRequestReviewCommentInputBuilder();

  GAddPullRequestReviewCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _commitOID = $v.commitOID;
      _inReplyTo = $v.inReplyTo;
      _path = $v.path;
      _position = $v.position;
      _pullRequestId = $v.pullRequestId;
      _pullRequestReviewId = $v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddPullRequestReviewCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddPullRequestReviewCommentInput;
  }

  @override
  void update(
      void Function(GAddPullRequestReviewCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddPullRequestReviewCommentInput build() {
    final _$result = _$v ??
        new _$GAddPullRequestReviewCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GAddPullRequestReviewCommentInput', 'body'),
            clientMutationId: clientMutationId,
            commitOID: commitOID,
            inReplyTo: inReplyTo,
            path: path,
            position: position,
            pullRequestId: pullRequestId,
            pullRequestReviewId: pullRequestReviewId);
    replace(_$result);
    return _$result;
  }
}

class _$GAddPullRequestReviewInput extends GAddPullRequestReviewInput {
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final BuiltList<GDraftPullRequestReviewComment>? comments;
  @override
  final String? commitOID;
  @override
  final GPullRequestReviewEvent? event;
  @override
  final String pullRequestId;
  @override
  final BuiltList<GDraftPullRequestReviewThread>? threads;

  factory _$GAddPullRequestReviewInput(
          [void Function(GAddPullRequestReviewInputBuilder)? updates]) =>
      (new GAddPullRequestReviewInputBuilder()..update(updates)).build();

  _$GAddPullRequestReviewInput._(
      {this.body,
      this.clientMutationId,
      this.comments,
      this.commitOID,
      this.event,
      required this.pullRequestId,
      this.threads})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GAddPullRequestReviewInput', 'pullRequestId');
  }

  @override
  GAddPullRequestReviewInput rebuild(
          void Function(GAddPullRequestReviewInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddPullRequestReviewInputBuilder toBuilder() =>
      new GAddPullRequestReviewInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddPullRequestReviewInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        comments == other.comments &&
        commitOID == other.commitOID &&
        event == other.event &&
        pullRequestId == other.pullRequestId &&
        threads == other.threads;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
                        comments.hashCode),
                    commitOID.hashCode),
                event.hashCode),
            pullRequestId.hashCode),
        threads.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddPullRequestReviewInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('comments', comments)
          ..add('commitOID', commitOID)
          ..add('event', event)
          ..add('pullRequestId', pullRequestId)
          ..add('threads', threads))
        .toString();
  }
}

class GAddPullRequestReviewInputBuilder
    implements
        Builder<GAddPullRequestReviewInput, GAddPullRequestReviewInputBuilder> {
  _$GAddPullRequestReviewInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  ListBuilder<GDraftPullRequestReviewComment>? _comments;
  ListBuilder<GDraftPullRequestReviewComment> get comments =>
      _$this._comments ??= new ListBuilder<GDraftPullRequestReviewComment>();
  set comments(ListBuilder<GDraftPullRequestReviewComment>? comments) =>
      _$this._comments = comments;

  String? _commitOID;
  String? get commitOID => _$this._commitOID;
  set commitOID(String? commitOID) => _$this._commitOID = commitOID;

  GPullRequestReviewEvent? _event;
  GPullRequestReviewEvent? get event => _$this._event;
  set event(GPullRequestReviewEvent? event) => _$this._event = event;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  ListBuilder<GDraftPullRequestReviewThread>? _threads;
  ListBuilder<GDraftPullRequestReviewThread> get threads =>
      _$this._threads ??= new ListBuilder<GDraftPullRequestReviewThread>();
  set threads(ListBuilder<GDraftPullRequestReviewThread>? threads) =>
      _$this._threads = threads;

  GAddPullRequestReviewInputBuilder();

  GAddPullRequestReviewInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _comments = $v.comments?.toBuilder();
      _commitOID = $v.commitOID;
      _event = $v.event;
      _pullRequestId = $v.pullRequestId;
      _threads = $v.threads?.toBuilder();
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddPullRequestReviewInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddPullRequestReviewInput;
  }

  @override
  void update(void Function(GAddPullRequestReviewInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddPullRequestReviewInput build() {
    _$GAddPullRequestReviewInput _$result;
    try {
      _$result = _$v ??
          new _$GAddPullRequestReviewInput._(
              body: body,
              clientMutationId: clientMutationId,
              comments: _comments?.build(),
              commitOID: commitOID,
              event: event,
              pullRequestId: BuiltValueNullFieldError.checkNotNull(
                  pullRequestId, 'GAddPullRequestReviewInput', 'pullRequestId'),
              threads: _threads?.build());
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'comments';
        _comments?.build();

        _$failedField = 'threads';
        _threads?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GAddPullRequestReviewInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GAddPullRequestReviewThreadInput
    extends GAddPullRequestReviewThreadInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final int line;
  @override
  final String path;
  @override
  final String? pullRequestId;
  @override
  final String? pullRequestReviewId;
  @override
  final GDiffSide? side;
  @override
  final int? startLine;
  @override
  final GDiffSide? startSide;

  factory _$GAddPullRequestReviewThreadInput(
          [void Function(GAddPullRequestReviewThreadInputBuilder)? updates]) =>
      (new GAddPullRequestReviewThreadInputBuilder()..update(updates)).build();

  _$GAddPullRequestReviewThreadInput._(
      {required this.body,
      this.clientMutationId,
      required this.line,
      required this.path,
      this.pullRequestId,
      this.pullRequestReviewId,
      this.side,
      this.startLine,
      this.startSide})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GAddPullRequestReviewThreadInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        line, 'GAddPullRequestReviewThreadInput', 'line');
    BuiltValueNullFieldError.checkNotNull(
        path, 'GAddPullRequestReviewThreadInput', 'path');
  }

  @override
  GAddPullRequestReviewThreadInput rebuild(
          void Function(GAddPullRequestReviewThreadInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddPullRequestReviewThreadInputBuilder toBuilder() =>
      new GAddPullRequestReviewThreadInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddPullRequestReviewThreadInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        line == other.line &&
        path == other.path &&
        pullRequestId == other.pullRequestId &&
        pullRequestReviewId == other.pullRequestReviewId &&
        side == other.side &&
        startLine == other.startLine &&
        startSide == other.startSide;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc($jc(0, body.hashCode),
                                    clientMutationId.hashCode),
                                line.hashCode),
                            path.hashCode),
                        pullRequestId.hashCode),
                    pullRequestReviewId.hashCode),
                side.hashCode),
            startLine.hashCode),
        startSide.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddPullRequestReviewThreadInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('line', line)
          ..add('path', path)
          ..add('pullRequestId', pullRequestId)
          ..add('pullRequestReviewId', pullRequestReviewId)
          ..add('side', side)
          ..add('startLine', startLine)
          ..add('startSide', startSide))
        .toString();
  }
}

class GAddPullRequestReviewThreadInputBuilder
    implements
        Builder<GAddPullRequestReviewThreadInput,
            GAddPullRequestReviewThreadInputBuilder> {
  _$GAddPullRequestReviewThreadInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  int? _line;
  int? get line => _$this._line;
  set line(int? line) => _$this._line = line;

  String? _path;
  String? get path => _$this._path;
  set path(String? path) => _$this._path = path;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  String? _pullRequestReviewId;
  String? get pullRequestReviewId => _$this._pullRequestReviewId;
  set pullRequestReviewId(String? pullRequestReviewId) =>
      _$this._pullRequestReviewId = pullRequestReviewId;

  GDiffSide? _side;
  GDiffSide? get side => _$this._side;
  set side(GDiffSide? side) => _$this._side = side;

  int? _startLine;
  int? get startLine => _$this._startLine;
  set startLine(int? startLine) => _$this._startLine = startLine;

  GDiffSide? _startSide;
  GDiffSide? get startSide => _$this._startSide;
  set startSide(GDiffSide? startSide) => _$this._startSide = startSide;

  GAddPullRequestReviewThreadInputBuilder();

  GAddPullRequestReviewThreadInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _line = $v.line;
      _path = $v.path;
      _pullRequestId = $v.pullRequestId;
      _pullRequestReviewId = $v.pullRequestReviewId;
      _side = $v.side;
      _startLine = $v.startLine;
      _startSide = $v.startSide;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddPullRequestReviewThreadInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddPullRequestReviewThreadInput;
  }

  @override
  void update(void Function(GAddPullRequestReviewThreadInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddPullRequestReviewThreadInput build() {
    final _$result = _$v ??
        new _$GAddPullRequestReviewThreadInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GAddPullRequestReviewThreadInput', 'body'),
            clientMutationId: clientMutationId,
            line: BuiltValueNullFieldError.checkNotNull(
                line, 'GAddPullRequestReviewThreadInput', 'line'),
            path: BuiltValueNullFieldError.checkNotNull(
                path, 'GAddPullRequestReviewThreadInput', 'path'),
            pullRequestId: pullRequestId,
            pullRequestReviewId: pullRequestReviewId,
            side: side,
            startLine: startLine,
            startSide: startSide);
    replace(_$result);
    return _$result;
  }
}

class _$GAddReactionInput extends GAddReactionInput {
  @override
  final String? clientMutationId;
  @override
  final GReactionContent content;
  @override
  final String subjectId;

  factory _$GAddReactionInput(
          [void Function(GAddReactionInputBuilder)? updates]) =>
      (new GAddReactionInputBuilder()..update(updates)).build();

  _$GAddReactionInput._(
      {this.clientMutationId, required this.content, required this.subjectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        content, 'GAddReactionInput', 'content');
    BuiltValueNullFieldError.checkNotNull(
        subjectId, 'GAddReactionInput', 'subjectId');
  }

  @override
  GAddReactionInput rebuild(void Function(GAddReactionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddReactionInputBuilder toBuilder() =>
      new GAddReactionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddReactionInput &&
        clientMutationId == other.clientMutationId &&
        content == other.content &&
        subjectId == other.subjectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), content.hashCode),
        subjectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddReactionInput')
          ..add('clientMutationId', clientMutationId)
          ..add('content', content)
          ..add('subjectId', subjectId))
        .toString();
  }
}

class GAddReactionInputBuilder
    implements Builder<GAddReactionInput, GAddReactionInputBuilder> {
  _$GAddReactionInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GReactionContent? _content;
  GReactionContent? get content => _$this._content;
  set content(GReactionContent? content) => _$this._content = content;

  String? _subjectId;
  String? get subjectId => _$this._subjectId;
  set subjectId(String? subjectId) => _$this._subjectId = subjectId;

  GAddReactionInputBuilder();

  GAddReactionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _content = $v.content;
      _subjectId = $v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddReactionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddReactionInput;
  }

  @override
  void update(void Function(GAddReactionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddReactionInput build() {
    final _$result = _$v ??
        new _$GAddReactionInput._(
            clientMutationId: clientMutationId,
            content: BuiltValueNullFieldError.checkNotNull(
                content, 'GAddReactionInput', 'content'),
            subjectId: BuiltValueNullFieldError.checkNotNull(
                subjectId, 'GAddReactionInput', 'subjectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddStarInput extends GAddStarInput {
  @override
  final String? clientMutationId;
  @override
  final String starrableId;

  factory _$GAddStarInput([void Function(GAddStarInputBuilder)? updates]) =>
      (new GAddStarInputBuilder()..update(updates)).build();

  _$GAddStarInput._({this.clientMutationId, required this.starrableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        starrableId, 'GAddStarInput', 'starrableId');
  }

  @override
  GAddStarInput rebuild(void Function(GAddStarInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddStarInputBuilder toBuilder() => new GAddStarInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddStarInput &&
        clientMutationId == other.clientMutationId &&
        starrableId == other.starrableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), starrableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddStarInput')
          ..add('clientMutationId', clientMutationId)
          ..add('starrableId', starrableId))
        .toString();
  }
}

class GAddStarInputBuilder
    implements Builder<GAddStarInput, GAddStarInputBuilder> {
  _$GAddStarInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _starrableId;
  String? get starrableId => _$this._starrableId;
  set starrableId(String? starrableId) => _$this._starrableId = starrableId;

  GAddStarInputBuilder();

  GAddStarInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _starrableId = $v.starrableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddStarInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddStarInput;
  }

  @override
  void update(void Function(GAddStarInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddStarInput build() {
    final _$result = _$v ??
        new _$GAddStarInput._(
            clientMutationId: clientMutationId,
            starrableId: BuiltValueNullFieldError.checkNotNull(
                starrableId, 'GAddStarInput', 'starrableId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddUpvoteInput extends GAddUpvoteInput {
  @override
  final String? clientMutationId;
  @override
  final String subjectId;

  factory _$GAddUpvoteInput([void Function(GAddUpvoteInputBuilder)? updates]) =>
      (new GAddUpvoteInputBuilder()..update(updates)).build();

  _$GAddUpvoteInput._({this.clientMutationId, required this.subjectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        subjectId, 'GAddUpvoteInput', 'subjectId');
  }

  @override
  GAddUpvoteInput rebuild(void Function(GAddUpvoteInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddUpvoteInputBuilder toBuilder() =>
      new GAddUpvoteInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddUpvoteInput &&
        clientMutationId == other.clientMutationId &&
        subjectId == other.subjectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), subjectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddUpvoteInput')
          ..add('clientMutationId', clientMutationId)
          ..add('subjectId', subjectId))
        .toString();
  }
}

class GAddUpvoteInputBuilder
    implements Builder<GAddUpvoteInput, GAddUpvoteInputBuilder> {
  _$GAddUpvoteInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _subjectId;
  String? get subjectId => _$this._subjectId;
  set subjectId(String? subjectId) => _$this._subjectId = subjectId;

  GAddUpvoteInputBuilder();

  GAddUpvoteInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _subjectId = $v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddUpvoteInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddUpvoteInput;
  }

  @override
  void update(void Function(GAddUpvoteInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddUpvoteInput build() {
    final _$result = _$v ??
        new _$GAddUpvoteInput._(
            clientMutationId: clientMutationId,
            subjectId: BuiltValueNullFieldError.checkNotNull(
                subjectId, 'GAddUpvoteInput', 'subjectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAddVerifiableDomainInput extends GAddVerifiableDomainInput {
  @override
  final String? clientMutationId;
  @override
  final String domain;
  @override
  final String ownerId;

  factory _$GAddVerifiableDomainInput(
          [void Function(GAddVerifiableDomainInputBuilder)? updates]) =>
      (new GAddVerifiableDomainInputBuilder()..update(updates)).build();

  _$GAddVerifiableDomainInput._(
      {this.clientMutationId, required this.domain, required this.ownerId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        domain, 'GAddVerifiableDomainInput', 'domain');
    BuiltValueNullFieldError.checkNotNull(
        ownerId, 'GAddVerifiableDomainInput', 'ownerId');
  }

  @override
  GAddVerifiableDomainInput rebuild(
          void Function(GAddVerifiableDomainInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAddVerifiableDomainInputBuilder toBuilder() =>
      new GAddVerifiableDomainInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAddVerifiableDomainInput &&
        clientMutationId == other.clientMutationId &&
        domain == other.domain &&
        ownerId == other.ownerId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), domain.hashCode),
        ownerId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAddVerifiableDomainInput')
          ..add('clientMutationId', clientMutationId)
          ..add('domain', domain)
          ..add('ownerId', ownerId))
        .toString();
  }
}

class GAddVerifiableDomainInputBuilder
    implements
        Builder<GAddVerifiableDomainInput, GAddVerifiableDomainInputBuilder> {
  _$GAddVerifiableDomainInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _domain;
  String? get domain => _$this._domain;
  set domain(String? domain) => _$this._domain = domain;

  String? _ownerId;
  String? get ownerId => _$this._ownerId;
  set ownerId(String? ownerId) => _$this._ownerId = ownerId;

  GAddVerifiableDomainInputBuilder();

  GAddVerifiableDomainInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _domain = $v.domain;
      _ownerId = $v.ownerId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddVerifiableDomainInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAddVerifiableDomainInput;
  }

  @override
  void update(void Function(GAddVerifiableDomainInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAddVerifiableDomainInput build() {
    final _$result = _$v ??
        new _$GAddVerifiableDomainInput._(
            clientMutationId: clientMutationId,
            domain: BuiltValueNullFieldError.checkNotNull(
                domain, 'GAddVerifiableDomainInput', 'domain'),
            ownerId: BuiltValueNullFieldError.checkNotNull(
                ownerId, 'GAddVerifiableDomainInput', 'ownerId'));
    replace(_$result);
    return _$result;
  }
}

class _$GApproveDeploymentsInput extends GApproveDeploymentsInput {
  @override
  final String? clientMutationId;
  @override
  final String? comment;
  @override
  final BuiltList<String> environmentIds;
  @override
  final String workflowRunId;

  factory _$GApproveDeploymentsInput(
          [void Function(GApproveDeploymentsInputBuilder)? updates]) =>
      (new GApproveDeploymentsInputBuilder()..update(updates)).build();

  _$GApproveDeploymentsInput._(
      {this.clientMutationId,
      this.comment,
      required this.environmentIds,
      required this.workflowRunId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        environmentIds, 'GApproveDeploymentsInput', 'environmentIds');
    BuiltValueNullFieldError.checkNotNull(
        workflowRunId, 'GApproveDeploymentsInput', 'workflowRunId');
  }

  @override
  GApproveDeploymentsInput rebuild(
          void Function(GApproveDeploymentsInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GApproveDeploymentsInputBuilder toBuilder() =>
      new GApproveDeploymentsInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GApproveDeploymentsInput &&
        clientMutationId == other.clientMutationId &&
        comment == other.comment &&
        environmentIds == other.environmentIds &&
        workflowRunId == other.workflowRunId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), comment.hashCode),
            environmentIds.hashCode),
        workflowRunId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GApproveDeploymentsInput')
          ..add('clientMutationId', clientMutationId)
          ..add('comment', comment)
          ..add('environmentIds', environmentIds)
          ..add('workflowRunId', workflowRunId))
        .toString();
  }
}

class GApproveDeploymentsInputBuilder
    implements
        Builder<GApproveDeploymentsInput, GApproveDeploymentsInputBuilder> {
  _$GApproveDeploymentsInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _comment;
  String? get comment => _$this._comment;
  set comment(String? comment) => _$this._comment = comment;

  ListBuilder<String>? _environmentIds;
  ListBuilder<String> get environmentIds =>
      _$this._environmentIds ??= new ListBuilder<String>();
  set environmentIds(ListBuilder<String>? environmentIds) =>
      _$this._environmentIds = environmentIds;

  String? _workflowRunId;
  String? get workflowRunId => _$this._workflowRunId;
  set workflowRunId(String? workflowRunId) =>
      _$this._workflowRunId = workflowRunId;

  GApproveDeploymentsInputBuilder();

  GApproveDeploymentsInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _comment = $v.comment;
      _environmentIds = $v.environmentIds.toBuilder();
      _workflowRunId = $v.workflowRunId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GApproveDeploymentsInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GApproveDeploymentsInput;
  }

  @override
  void update(void Function(GApproveDeploymentsInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GApproveDeploymentsInput build() {
    _$GApproveDeploymentsInput _$result;
    try {
      _$result = _$v ??
          new _$GApproveDeploymentsInput._(
              clientMutationId: clientMutationId,
              comment: comment,
              environmentIds: environmentIds.build(),
              workflowRunId: BuiltValueNullFieldError.checkNotNull(
                  workflowRunId, 'GApproveDeploymentsInput', 'workflowRunId'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'environmentIds';
        environmentIds.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GApproveDeploymentsInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GApproveVerifiableDomainInput extends GApproveVerifiableDomainInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GApproveVerifiableDomainInput(
          [void Function(GApproveVerifiableDomainInputBuilder)? updates]) =>
      (new GApproveVerifiableDomainInputBuilder()..update(updates)).build();

  _$GApproveVerifiableDomainInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GApproveVerifiableDomainInput', 'id');
  }

  @override
  GApproveVerifiableDomainInput rebuild(
          void Function(GApproveVerifiableDomainInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GApproveVerifiableDomainInputBuilder toBuilder() =>
      new GApproveVerifiableDomainInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GApproveVerifiableDomainInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GApproveVerifiableDomainInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GApproveVerifiableDomainInputBuilder
    implements
        Builder<GApproveVerifiableDomainInput,
            GApproveVerifiableDomainInputBuilder> {
  _$GApproveVerifiableDomainInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GApproveVerifiableDomainInputBuilder();

  GApproveVerifiableDomainInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GApproveVerifiableDomainInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GApproveVerifiableDomainInput;
  }

  @override
  void update(void Function(GApproveVerifiableDomainInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GApproveVerifiableDomainInput build() {
    final _$result = _$v ??
        new _$GApproveVerifiableDomainInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GApproveVerifiableDomainInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GArchiveRepositoryInput extends GArchiveRepositoryInput {
  @override
  final String? clientMutationId;
  @override
  final String repositoryId;

  factory _$GArchiveRepositoryInput(
          [void Function(GArchiveRepositoryInputBuilder)? updates]) =>
      (new GArchiveRepositoryInputBuilder()..update(updates)).build();

  _$GArchiveRepositoryInput._(
      {this.clientMutationId, required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GArchiveRepositoryInput', 'repositoryId');
  }

  @override
  GArchiveRepositoryInput rebuild(
          void Function(GArchiveRepositoryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GArchiveRepositoryInputBuilder toBuilder() =>
      new GArchiveRepositoryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GArchiveRepositoryInput &&
        clientMutationId == other.clientMutationId &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GArchiveRepositoryInput')
          ..add('clientMutationId', clientMutationId)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GArchiveRepositoryInputBuilder
    implements
        Builder<GArchiveRepositoryInput, GArchiveRepositoryInputBuilder> {
  _$GArchiveRepositoryInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GArchiveRepositoryInputBuilder();

  GArchiveRepositoryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GArchiveRepositoryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GArchiveRepositoryInput;
  }

  @override
  void update(void Function(GArchiveRepositoryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GArchiveRepositoryInput build() {
    final _$result = _$v ??
        new _$GArchiveRepositoryInput._(
            clientMutationId: clientMutationId,
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GArchiveRepositoryInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GAuditLogOrder extends GAuditLogOrder {
  @override
  final GOrderDirection? direction;
  @override
  final GAuditLogOrderField? field;

  factory _$GAuditLogOrder([void Function(GAuditLogOrderBuilder)? updates]) =>
      (new GAuditLogOrderBuilder()..update(updates)).build();

  _$GAuditLogOrder._({this.direction, this.field}) : super._();

  @override
  GAuditLogOrder rebuild(void Function(GAuditLogOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GAuditLogOrderBuilder toBuilder() =>
      new GAuditLogOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GAuditLogOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GAuditLogOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GAuditLogOrderBuilder
    implements Builder<GAuditLogOrder, GAuditLogOrderBuilder> {
  _$GAuditLogOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GAuditLogOrderField? _field;
  GAuditLogOrderField? get field => _$this._field;
  set field(GAuditLogOrderField? field) => _$this._field = field;

  GAuditLogOrderBuilder();

  GAuditLogOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAuditLogOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GAuditLogOrder;
  }

  @override
  void update(void Function(GAuditLogOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GAuditLogOrder build() {
    final _$result =
        _$v ?? new _$GAuditLogOrder._(direction: direction, field: field);
    replace(_$result);
    return _$result;
  }
}

class _$GCancelEnterpriseAdminInvitationInput
    extends GCancelEnterpriseAdminInvitationInput {
  @override
  final String? clientMutationId;
  @override
  final String invitationId;

  factory _$GCancelEnterpriseAdminInvitationInput(
          [void Function(GCancelEnterpriseAdminInvitationInputBuilder)?
              updates]) =>
      (new GCancelEnterpriseAdminInvitationInputBuilder()..update(updates))
          .build();

  _$GCancelEnterpriseAdminInvitationInput._(
      {this.clientMutationId, required this.invitationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        invitationId, 'GCancelEnterpriseAdminInvitationInput', 'invitationId');
  }

  @override
  GCancelEnterpriseAdminInvitationInput rebuild(
          void Function(GCancelEnterpriseAdminInvitationInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCancelEnterpriseAdminInvitationInputBuilder toBuilder() =>
      new GCancelEnterpriseAdminInvitationInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCancelEnterpriseAdminInvitationInput &&
        clientMutationId == other.clientMutationId &&
        invitationId == other.invitationId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), invitationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCancelEnterpriseAdminInvitationInput')
          ..add('clientMutationId', clientMutationId)
          ..add('invitationId', invitationId))
        .toString();
  }
}

class GCancelEnterpriseAdminInvitationInputBuilder
    implements
        Builder<GCancelEnterpriseAdminInvitationInput,
            GCancelEnterpriseAdminInvitationInputBuilder> {
  _$GCancelEnterpriseAdminInvitationInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _invitationId;
  String? get invitationId => _$this._invitationId;
  set invitationId(String? invitationId) => _$this._invitationId = invitationId;

  GCancelEnterpriseAdminInvitationInputBuilder();

  GCancelEnterpriseAdminInvitationInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _invitationId = $v.invitationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCancelEnterpriseAdminInvitationInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCancelEnterpriseAdminInvitationInput;
  }

  @override
  void update(
      void Function(GCancelEnterpriseAdminInvitationInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCancelEnterpriseAdminInvitationInput build() {
    final _$result = _$v ??
        new _$GCancelEnterpriseAdminInvitationInput._(
            clientMutationId: clientMutationId,
            invitationId: BuiltValueNullFieldError.checkNotNull(invitationId,
                'GCancelEnterpriseAdminInvitationInput', 'invitationId'));
    replace(_$result);
    return _$result;
  }
}

class _$GChangeUserStatusInput extends GChangeUserStatusInput {
  @override
  final String? clientMutationId;
  @override
  final String? emoji;
  @override
  final DateTime? expiresAt;
  @override
  final bool? limitedAvailability;
  @override
  final String? message;
  @override
  final String? organizationId;

  factory _$GChangeUserStatusInput(
          [void Function(GChangeUserStatusInputBuilder)? updates]) =>
      (new GChangeUserStatusInputBuilder()..update(updates)).build();

  _$GChangeUserStatusInput._(
      {this.clientMutationId,
      this.emoji,
      this.expiresAt,
      this.limitedAvailability,
      this.message,
      this.organizationId})
      : super._();

  @override
  GChangeUserStatusInput rebuild(
          void Function(GChangeUserStatusInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GChangeUserStatusInputBuilder toBuilder() =>
      new GChangeUserStatusInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GChangeUserStatusInput &&
        clientMutationId == other.clientMutationId &&
        emoji == other.emoji &&
        expiresAt == other.expiresAt &&
        limitedAvailability == other.limitedAvailability &&
        message == other.message &&
        organizationId == other.organizationId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc($jc($jc(0, clientMutationId.hashCode), emoji.hashCode),
                    expiresAt.hashCode),
                limitedAvailability.hashCode),
            message.hashCode),
        organizationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GChangeUserStatusInput')
          ..add('clientMutationId', clientMutationId)
          ..add('emoji', emoji)
          ..add('expiresAt', expiresAt)
          ..add('limitedAvailability', limitedAvailability)
          ..add('message', message)
          ..add('organizationId', organizationId))
        .toString();
  }
}

class GChangeUserStatusInputBuilder
    implements Builder<GChangeUserStatusInput, GChangeUserStatusInputBuilder> {
  _$GChangeUserStatusInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _emoji;
  String? get emoji => _$this._emoji;
  set emoji(String? emoji) => _$this._emoji = emoji;

  DateTime? _expiresAt;
  DateTime? get expiresAt => _$this._expiresAt;
  set expiresAt(DateTime? expiresAt) => _$this._expiresAt = expiresAt;

  bool? _limitedAvailability;
  bool? get limitedAvailability => _$this._limitedAvailability;
  set limitedAvailability(bool? limitedAvailability) =>
      _$this._limitedAvailability = limitedAvailability;

  String? _message;
  String? get message => _$this._message;
  set message(String? message) => _$this._message = message;

  String? _organizationId;
  String? get organizationId => _$this._organizationId;
  set organizationId(String? organizationId) =>
      _$this._organizationId = organizationId;

  GChangeUserStatusInputBuilder();

  GChangeUserStatusInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _emoji = $v.emoji;
      _expiresAt = $v.expiresAt;
      _limitedAvailability = $v.limitedAvailability;
      _message = $v.message;
      _organizationId = $v.organizationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GChangeUserStatusInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GChangeUserStatusInput;
  }

  @override
  void update(void Function(GChangeUserStatusInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GChangeUserStatusInput build() {
    final _$result = _$v ??
        new _$GChangeUserStatusInput._(
            clientMutationId: clientMutationId,
            emoji: emoji,
            expiresAt: expiresAt,
            limitedAvailability: limitedAvailability,
            message: message,
            organizationId: organizationId);
    replace(_$result);
    return _$result;
  }
}

class _$GCheckAnnotationData extends GCheckAnnotationData {
  @override
  final GCheckAnnotationLevel annotationLevel;
  @override
  final GCheckAnnotationRange location;
  @override
  final String message;
  @override
  final String path;
  @override
  final String? rawDetails;
  @override
  final String? title;

  factory _$GCheckAnnotationData(
          [void Function(GCheckAnnotationDataBuilder)? updates]) =>
      (new GCheckAnnotationDataBuilder()..update(updates)).build();

  _$GCheckAnnotationData._(
      {required this.annotationLevel,
      required this.location,
      required this.message,
      required this.path,
      this.rawDetails,
      this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        annotationLevel, 'GCheckAnnotationData', 'annotationLevel');
    BuiltValueNullFieldError.checkNotNull(
        location, 'GCheckAnnotationData', 'location');
    BuiltValueNullFieldError.checkNotNull(
        message, 'GCheckAnnotationData', 'message');
    BuiltValueNullFieldError.checkNotNull(path, 'GCheckAnnotationData', 'path');
  }

  @override
  GCheckAnnotationData rebuild(
          void Function(GCheckAnnotationDataBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckAnnotationDataBuilder toBuilder() =>
      new GCheckAnnotationDataBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckAnnotationData &&
        annotationLevel == other.annotationLevel &&
        location == other.location &&
        message == other.message &&
        path == other.path &&
        rawDetails == other.rawDetails &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc($jc($jc(0, annotationLevel.hashCode), location.hashCode),
                    message.hashCode),
                path.hashCode),
            rawDetails.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckAnnotationData')
          ..add('annotationLevel', annotationLevel)
          ..add('location', location)
          ..add('message', message)
          ..add('path', path)
          ..add('rawDetails', rawDetails)
          ..add('title', title))
        .toString();
  }
}

class GCheckAnnotationDataBuilder
    implements Builder<GCheckAnnotationData, GCheckAnnotationDataBuilder> {
  _$GCheckAnnotationData? _$v;

  GCheckAnnotationLevel? _annotationLevel;
  GCheckAnnotationLevel? get annotationLevel => _$this._annotationLevel;
  set annotationLevel(GCheckAnnotationLevel? annotationLevel) =>
      _$this._annotationLevel = annotationLevel;

  GCheckAnnotationRangeBuilder? _location;
  GCheckAnnotationRangeBuilder get location =>
      _$this._location ??= new GCheckAnnotationRangeBuilder();
  set location(GCheckAnnotationRangeBuilder? location) =>
      _$this._location = location;

  String? _message;
  String? get message => _$this._message;
  set message(String? message) => _$this._message = message;

  String? _path;
  String? get path => _$this._path;
  set path(String? path) => _$this._path = path;

  String? _rawDetails;
  String? get rawDetails => _$this._rawDetails;
  set rawDetails(String? rawDetails) => _$this._rawDetails = rawDetails;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GCheckAnnotationDataBuilder();

  GCheckAnnotationDataBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _annotationLevel = $v.annotationLevel;
      _location = $v.location.toBuilder();
      _message = $v.message;
      _path = $v.path;
      _rawDetails = $v.rawDetails;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckAnnotationData other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckAnnotationData;
  }

  @override
  void update(void Function(GCheckAnnotationDataBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckAnnotationData build() {
    _$GCheckAnnotationData _$result;
    try {
      _$result = _$v ??
          new _$GCheckAnnotationData._(
              annotationLevel: BuiltValueNullFieldError.checkNotNull(
                  annotationLevel, 'GCheckAnnotationData', 'annotationLevel'),
              location: location.build(),
              message: BuiltValueNullFieldError.checkNotNull(
                  message, 'GCheckAnnotationData', 'message'),
              path: BuiltValueNullFieldError.checkNotNull(
                  path, 'GCheckAnnotationData', 'path'),
              rawDetails: rawDetails,
              title: title);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'location';
        location.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCheckAnnotationData', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCheckAnnotationRange extends GCheckAnnotationRange {
  @override
  final int? endColumn;
  @override
  final int endLine;
  @override
  final int? startColumn;
  @override
  final int startLine;

  factory _$GCheckAnnotationRange(
          [void Function(GCheckAnnotationRangeBuilder)? updates]) =>
      (new GCheckAnnotationRangeBuilder()..update(updates)).build();

  _$GCheckAnnotationRange._(
      {this.endColumn,
      required this.endLine,
      this.startColumn,
      required this.startLine})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        endLine, 'GCheckAnnotationRange', 'endLine');
    BuiltValueNullFieldError.checkNotNull(
        startLine, 'GCheckAnnotationRange', 'startLine');
  }

  @override
  GCheckAnnotationRange rebuild(
          void Function(GCheckAnnotationRangeBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckAnnotationRangeBuilder toBuilder() =>
      new GCheckAnnotationRangeBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckAnnotationRange &&
        endColumn == other.endColumn &&
        endLine == other.endLine &&
        startColumn == other.startColumn &&
        startLine == other.startLine;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, endColumn.hashCode), endLine.hashCode),
            startColumn.hashCode),
        startLine.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckAnnotationRange')
          ..add('endColumn', endColumn)
          ..add('endLine', endLine)
          ..add('startColumn', startColumn)
          ..add('startLine', startLine))
        .toString();
  }
}

class GCheckAnnotationRangeBuilder
    implements Builder<GCheckAnnotationRange, GCheckAnnotationRangeBuilder> {
  _$GCheckAnnotationRange? _$v;

  int? _endColumn;
  int? get endColumn => _$this._endColumn;
  set endColumn(int? endColumn) => _$this._endColumn = endColumn;

  int? _endLine;
  int? get endLine => _$this._endLine;
  set endLine(int? endLine) => _$this._endLine = endLine;

  int? _startColumn;
  int? get startColumn => _$this._startColumn;
  set startColumn(int? startColumn) => _$this._startColumn = startColumn;

  int? _startLine;
  int? get startLine => _$this._startLine;
  set startLine(int? startLine) => _$this._startLine = startLine;

  GCheckAnnotationRangeBuilder();

  GCheckAnnotationRangeBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _endColumn = $v.endColumn;
      _endLine = $v.endLine;
      _startColumn = $v.startColumn;
      _startLine = $v.startLine;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckAnnotationRange other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckAnnotationRange;
  }

  @override
  void update(void Function(GCheckAnnotationRangeBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckAnnotationRange build() {
    final _$result = _$v ??
        new _$GCheckAnnotationRange._(
            endColumn: endColumn,
            endLine: BuiltValueNullFieldError.checkNotNull(
                endLine, 'GCheckAnnotationRange', 'endLine'),
            startColumn: startColumn,
            startLine: BuiltValueNullFieldError.checkNotNull(
                startLine, 'GCheckAnnotationRange', 'startLine'));
    replace(_$result);
    return _$result;
  }
}

class _$GCheckRunAction extends GCheckRunAction {
  @override
  final String description;
  @override
  final String identifier;
  @override
  final String label;

  factory _$GCheckRunAction([void Function(GCheckRunActionBuilder)? updates]) =>
      (new GCheckRunActionBuilder()..update(updates)).build();

  _$GCheckRunAction._(
      {required this.description,
      required this.identifier,
      required this.label})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        description, 'GCheckRunAction', 'description');
    BuiltValueNullFieldError.checkNotNull(
        identifier, 'GCheckRunAction', 'identifier');
    BuiltValueNullFieldError.checkNotNull(label, 'GCheckRunAction', 'label');
  }

  @override
  GCheckRunAction rebuild(void Function(GCheckRunActionBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckRunActionBuilder toBuilder() =>
      new GCheckRunActionBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckRunAction &&
        description == other.description &&
        identifier == other.identifier &&
        label == other.label;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, description.hashCode), identifier.hashCode),
        label.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckRunAction')
          ..add('description', description)
          ..add('identifier', identifier)
          ..add('label', label))
        .toString();
  }
}

class GCheckRunActionBuilder
    implements Builder<GCheckRunAction, GCheckRunActionBuilder> {
  _$GCheckRunAction? _$v;

  String? _description;
  String? get description => _$this._description;
  set description(String? description) => _$this._description = description;

  String? _identifier;
  String? get identifier => _$this._identifier;
  set identifier(String? identifier) => _$this._identifier = identifier;

  String? _label;
  String? get label => _$this._label;
  set label(String? label) => _$this._label = label;

  GCheckRunActionBuilder();

  GCheckRunActionBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _description = $v.description;
      _identifier = $v.identifier;
      _label = $v.label;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckRunAction other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckRunAction;
  }

  @override
  void update(void Function(GCheckRunActionBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckRunAction build() {
    final _$result = _$v ??
        new _$GCheckRunAction._(
            description: BuiltValueNullFieldError.checkNotNull(
                description, 'GCheckRunAction', 'description'),
            identifier: BuiltValueNullFieldError.checkNotNull(
                identifier, 'GCheckRunAction', 'identifier'),
            label: BuiltValueNullFieldError.checkNotNull(
                label, 'GCheckRunAction', 'label'));
    replace(_$result);
    return _$result;
  }
}

class _$GCheckRunFilter extends GCheckRunFilter {
  @override
  final int? appId;
  @override
  final String? checkName;
  @override
  final GCheckRunType? checkType;
  @override
  final GCheckStatusState? status;

  factory _$GCheckRunFilter([void Function(GCheckRunFilterBuilder)? updates]) =>
      (new GCheckRunFilterBuilder()..update(updates)).build();

  _$GCheckRunFilter._({this.appId, this.checkName, this.checkType, this.status})
      : super._();

  @override
  GCheckRunFilter rebuild(void Function(GCheckRunFilterBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckRunFilterBuilder toBuilder() =>
      new GCheckRunFilterBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckRunFilter &&
        appId == other.appId &&
        checkName == other.checkName &&
        checkType == other.checkType &&
        status == other.status;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, appId.hashCode), checkName.hashCode),
            checkType.hashCode),
        status.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckRunFilter')
          ..add('appId', appId)
          ..add('checkName', checkName)
          ..add('checkType', checkType)
          ..add('status', status))
        .toString();
  }
}

class GCheckRunFilterBuilder
    implements Builder<GCheckRunFilter, GCheckRunFilterBuilder> {
  _$GCheckRunFilter? _$v;

  int? _appId;
  int? get appId => _$this._appId;
  set appId(int? appId) => _$this._appId = appId;

  String? _checkName;
  String? get checkName => _$this._checkName;
  set checkName(String? checkName) => _$this._checkName = checkName;

  GCheckRunType? _checkType;
  GCheckRunType? get checkType => _$this._checkType;
  set checkType(GCheckRunType? checkType) => _$this._checkType = checkType;

  GCheckStatusState? _status;
  GCheckStatusState? get status => _$this._status;
  set status(GCheckStatusState? status) => _$this._status = status;

  GCheckRunFilterBuilder();

  GCheckRunFilterBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _appId = $v.appId;
      _checkName = $v.checkName;
      _checkType = $v.checkType;
      _status = $v.status;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckRunFilter other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckRunFilter;
  }

  @override
  void update(void Function(GCheckRunFilterBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckRunFilter build() {
    final _$result = _$v ??
        new _$GCheckRunFilter._(
            appId: appId,
            checkName: checkName,
            checkType: checkType,
            status: status);
    replace(_$result);
    return _$result;
  }
}

class _$GCheckRunOutput extends GCheckRunOutput {
  @override
  final BuiltList<GCheckAnnotationData>? annotations;
  @override
  final BuiltList<GCheckRunOutputImage>? images;
  @override
  final String summary;
  @override
  final String? text;
  @override
  final String title;

  factory _$GCheckRunOutput([void Function(GCheckRunOutputBuilder)? updates]) =>
      (new GCheckRunOutputBuilder()..update(updates)).build();

  _$GCheckRunOutput._(
      {this.annotations,
      this.images,
      required this.summary,
      this.text,
      required this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        summary, 'GCheckRunOutput', 'summary');
    BuiltValueNullFieldError.checkNotNull(title, 'GCheckRunOutput', 'title');
  }

  @override
  GCheckRunOutput rebuild(void Function(GCheckRunOutputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckRunOutputBuilder toBuilder() =>
      new GCheckRunOutputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckRunOutput &&
        annotations == other.annotations &&
        images == other.images &&
        summary == other.summary &&
        text == other.text &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, annotations.hashCode), images.hashCode),
                summary.hashCode),
            text.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckRunOutput')
          ..add('annotations', annotations)
          ..add('images', images)
          ..add('summary', summary)
          ..add('text', text)
          ..add('title', title))
        .toString();
  }
}

class GCheckRunOutputBuilder
    implements Builder<GCheckRunOutput, GCheckRunOutputBuilder> {
  _$GCheckRunOutput? _$v;

  ListBuilder<GCheckAnnotationData>? _annotations;
  ListBuilder<GCheckAnnotationData> get annotations =>
      _$this._annotations ??= new ListBuilder<GCheckAnnotationData>();
  set annotations(ListBuilder<GCheckAnnotationData>? annotations) =>
      _$this._annotations = annotations;

  ListBuilder<GCheckRunOutputImage>? _images;
  ListBuilder<GCheckRunOutputImage> get images =>
      _$this._images ??= new ListBuilder<GCheckRunOutputImage>();
  set images(ListBuilder<GCheckRunOutputImage>? images) =>
      _$this._images = images;

  String? _summary;
  String? get summary => _$this._summary;
  set summary(String? summary) => _$this._summary = summary;

  String? _text;
  String? get text => _$this._text;
  set text(String? text) => _$this._text = text;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GCheckRunOutputBuilder();

  GCheckRunOutputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _annotations = $v.annotations?.toBuilder();
      _images = $v.images?.toBuilder();
      _summary = $v.summary;
      _text = $v.text;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckRunOutput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckRunOutput;
  }

  @override
  void update(void Function(GCheckRunOutputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckRunOutput build() {
    _$GCheckRunOutput _$result;
    try {
      _$result = _$v ??
          new _$GCheckRunOutput._(
              annotations: _annotations?.build(),
              images: _images?.build(),
              summary: BuiltValueNullFieldError.checkNotNull(
                  summary, 'GCheckRunOutput', 'summary'),
              text: text,
              title: BuiltValueNullFieldError.checkNotNull(
                  title, 'GCheckRunOutput', 'title'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'annotations';
        _annotations?.build();
        _$failedField = 'images';
        _images?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCheckRunOutput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCheckRunOutputImage extends GCheckRunOutputImage {
  @override
  final String alt;
  @override
  final String? caption;
  @override
  final String imageUrl;

  factory _$GCheckRunOutputImage(
          [void Function(GCheckRunOutputImageBuilder)? updates]) =>
      (new GCheckRunOutputImageBuilder()..update(updates)).build();

  _$GCheckRunOutputImage._(
      {required this.alt, this.caption, required this.imageUrl})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(alt, 'GCheckRunOutputImage', 'alt');
    BuiltValueNullFieldError.checkNotNull(
        imageUrl, 'GCheckRunOutputImage', 'imageUrl');
  }

  @override
  GCheckRunOutputImage rebuild(
          void Function(GCheckRunOutputImageBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckRunOutputImageBuilder toBuilder() =>
      new GCheckRunOutputImageBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckRunOutputImage &&
        alt == other.alt &&
        caption == other.caption &&
        imageUrl == other.imageUrl;
  }

  @override
  int get hashCode {
    return $jf(
        $jc($jc($jc(0, alt.hashCode), caption.hashCode), imageUrl.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckRunOutputImage')
          ..add('alt', alt)
          ..add('caption', caption)
          ..add('imageUrl', imageUrl))
        .toString();
  }
}

class GCheckRunOutputImageBuilder
    implements Builder<GCheckRunOutputImage, GCheckRunOutputImageBuilder> {
  _$GCheckRunOutputImage? _$v;

  String? _alt;
  String? get alt => _$this._alt;
  set alt(String? alt) => _$this._alt = alt;

  String? _caption;
  String? get caption => _$this._caption;
  set caption(String? caption) => _$this._caption = caption;

  String? _imageUrl;
  String? get imageUrl => _$this._imageUrl;
  set imageUrl(String? imageUrl) => _$this._imageUrl = imageUrl;

  GCheckRunOutputImageBuilder();

  GCheckRunOutputImageBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _alt = $v.alt;
      _caption = $v.caption;
      _imageUrl = $v.imageUrl;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckRunOutputImage other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckRunOutputImage;
  }

  @override
  void update(void Function(GCheckRunOutputImageBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckRunOutputImage build() {
    final _$result = _$v ??
        new _$GCheckRunOutputImage._(
            alt: BuiltValueNullFieldError.checkNotNull(
                alt, 'GCheckRunOutputImage', 'alt'),
            caption: caption,
            imageUrl: BuiltValueNullFieldError.checkNotNull(
                imageUrl, 'GCheckRunOutputImage', 'imageUrl'));
    replace(_$result);
    return _$result;
  }
}

class _$GCheckSuiteAutoTriggerPreference
    extends GCheckSuiteAutoTriggerPreference {
  @override
  final String appId;
  @override
  final bool setting;

  factory _$GCheckSuiteAutoTriggerPreference(
          [void Function(GCheckSuiteAutoTriggerPreferenceBuilder)? updates]) =>
      (new GCheckSuiteAutoTriggerPreferenceBuilder()..update(updates)).build();

  _$GCheckSuiteAutoTriggerPreference._(
      {required this.appId, required this.setting})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        appId, 'GCheckSuiteAutoTriggerPreference', 'appId');
    BuiltValueNullFieldError.checkNotNull(
        setting, 'GCheckSuiteAutoTriggerPreference', 'setting');
  }

  @override
  GCheckSuiteAutoTriggerPreference rebuild(
          void Function(GCheckSuiteAutoTriggerPreferenceBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckSuiteAutoTriggerPreferenceBuilder toBuilder() =>
      new GCheckSuiteAutoTriggerPreferenceBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckSuiteAutoTriggerPreference &&
        appId == other.appId &&
        setting == other.setting;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, appId.hashCode), setting.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckSuiteAutoTriggerPreference')
          ..add('appId', appId)
          ..add('setting', setting))
        .toString();
  }
}

class GCheckSuiteAutoTriggerPreferenceBuilder
    implements
        Builder<GCheckSuiteAutoTriggerPreference,
            GCheckSuiteAutoTriggerPreferenceBuilder> {
  _$GCheckSuiteAutoTriggerPreference? _$v;

  String? _appId;
  String? get appId => _$this._appId;
  set appId(String? appId) => _$this._appId = appId;

  bool? _setting;
  bool? get setting => _$this._setting;
  set setting(bool? setting) => _$this._setting = setting;

  GCheckSuiteAutoTriggerPreferenceBuilder();

  GCheckSuiteAutoTriggerPreferenceBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _appId = $v.appId;
      _setting = $v.setting;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckSuiteAutoTriggerPreference other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckSuiteAutoTriggerPreference;
  }

  @override
  void update(void Function(GCheckSuiteAutoTriggerPreferenceBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckSuiteAutoTriggerPreference build() {
    final _$result = _$v ??
        new _$GCheckSuiteAutoTriggerPreference._(
            appId: BuiltValueNullFieldError.checkNotNull(
                appId, 'GCheckSuiteAutoTriggerPreference', 'appId'),
            setting: BuiltValueNullFieldError.checkNotNull(
                setting, 'GCheckSuiteAutoTriggerPreference', 'setting'));
    replace(_$result);
    return _$result;
  }
}

class _$GCheckSuiteFilter extends GCheckSuiteFilter {
  @override
  final int? appId;
  @override
  final String? checkName;

  factory _$GCheckSuiteFilter(
          [void Function(GCheckSuiteFilterBuilder)? updates]) =>
      (new GCheckSuiteFilterBuilder()..update(updates)).build();

  _$GCheckSuiteFilter._({this.appId, this.checkName}) : super._();

  @override
  GCheckSuiteFilter rebuild(void Function(GCheckSuiteFilterBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCheckSuiteFilterBuilder toBuilder() =>
      new GCheckSuiteFilterBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCheckSuiteFilter &&
        appId == other.appId &&
        checkName == other.checkName;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, appId.hashCode), checkName.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCheckSuiteFilter')
          ..add('appId', appId)
          ..add('checkName', checkName))
        .toString();
  }
}

class GCheckSuiteFilterBuilder
    implements Builder<GCheckSuiteFilter, GCheckSuiteFilterBuilder> {
  _$GCheckSuiteFilter? _$v;

  int? _appId;
  int? get appId => _$this._appId;
  set appId(int? appId) => _$this._appId = appId;

  String? _checkName;
  String? get checkName => _$this._checkName;
  set checkName(String? checkName) => _$this._checkName = checkName;

  GCheckSuiteFilterBuilder();

  GCheckSuiteFilterBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _appId = $v.appId;
      _checkName = $v.checkName;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckSuiteFilter other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCheckSuiteFilter;
  }

  @override
  void update(void Function(GCheckSuiteFilterBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCheckSuiteFilter build() {
    final _$result =
        _$v ?? new _$GCheckSuiteFilter._(appId: appId, checkName: checkName);
    replace(_$result);
    return _$result;
  }
}

class _$GClearLabelsFromLabelableInput extends GClearLabelsFromLabelableInput {
  @override
  final String? clientMutationId;
  @override
  final String labelableId;

  factory _$GClearLabelsFromLabelableInput(
          [void Function(GClearLabelsFromLabelableInputBuilder)? updates]) =>
      (new GClearLabelsFromLabelableInputBuilder()..update(updates)).build();

  _$GClearLabelsFromLabelableInput._(
      {this.clientMutationId, required this.labelableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        labelableId, 'GClearLabelsFromLabelableInput', 'labelableId');
  }

  @override
  GClearLabelsFromLabelableInput rebuild(
          void Function(GClearLabelsFromLabelableInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GClearLabelsFromLabelableInputBuilder toBuilder() =>
      new GClearLabelsFromLabelableInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GClearLabelsFromLabelableInput &&
        clientMutationId == other.clientMutationId &&
        labelableId == other.labelableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), labelableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GClearLabelsFromLabelableInput')
          ..add('clientMutationId', clientMutationId)
          ..add('labelableId', labelableId))
        .toString();
  }
}

class GClearLabelsFromLabelableInputBuilder
    implements
        Builder<GClearLabelsFromLabelableInput,
            GClearLabelsFromLabelableInputBuilder> {
  _$GClearLabelsFromLabelableInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _labelableId;
  String? get labelableId => _$this._labelableId;
  set labelableId(String? labelableId) => _$this._labelableId = labelableId;

  GClearLabelsFromLabelableInputBuilder();

  GClearLabelsFromLabelableInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _labelableId = $v.labelableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GClearLabelsFromLabelableInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GClearLabelsFromLabelableInput;
  }

  @override
  void update(void Function(GClearLabelsFromLabelableInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GClearLabelsFromLabelableInput build() {
    final _$result = _$v ??
        new _$GClearLabelsFromLabelableInput._(
            clientMutationId: clientMutationId,
            labelableId: BuiltValueNullFieldError.checkNotNull(
                labelableId, 'GClearLabelsFromLabelableInput', 'labelableId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCloneProjectInput extends GCloneProjectInput {
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final bool includeWorkflows;
  @override
  final String name;
  @override
  final bool? public;
  @override
  final String sourceId;
  @override
  final String targetOwnerId;

  factory _$GCloneProjectInput(
          [void Function(GCloneProjectInputBuilder)? updates]) =>
      (new GCloneProjectInputBuilder()..update(updates)).build();

  _$GCloneProjectInput._(
      {this.body,
      this.clientMutationId,
      required this.includeWorkflows,
      required this.name,
      this.public,
      required this.sourceId,
      required this.targetOwnerId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        includeWorkflows, 'GCloneProjectInput', 'includeWorkflows');
    BuiltValueNullFieldError.checkNotNull(name, 'GCloneProjectInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        sourceId, 'GCloneProjectInput', 'sourceId');
    BuiltValueNullFieldError.checkNotNull(
        targetOwnerId, 'GCloneProjectInput', 'targetOwnerId');
  }

  @override
  GCloneProjectInput rebuild(
          void Function(GCloneProjectInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCloneProjectInputBuilder toBuilder() =>
      new GCloneProjectInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCloneProjectInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        includeWorkflows == other.includeWorkflows &&
        name == other.name &&
        public == other.public &&
        sourceId == other.sourceId &&
        targetOwnerId == other.targetOwnerId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
                        includeWorkflows.hashCode),
                    name.hashCode),
                public.hashCode),
            sourceId.hashCode),
        targetOwnerId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCloneProjectInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('includeWorkflows', includeWorkflows)
          ..add('name', name)
          ..add('public', public)
          ..add('sourceId', sourceId)
          ..add('targetOwnerId', targetOwnerId))
        .toString();
  }
}

class GCloneProjectInputBuilder
    implements Builder<GCloneProjectInput, GCloneProjectInputBuilder> {
  _$GCloneProjectInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _includeWorkflows;
  bool? get includeWorkflows => _$this._includeWorkflows;
  set includeWorkflows(bool? includeWorkflows) =>
      _$this._includeWorkflows = includeWorkflows;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  bool? _public;
  bool? get public => _$this._public;
  set public(bool? public) => _$this._public = public;

  String? _sourceId;
  String? get sourceId => _$this._sourceId;
  set sourceId(String? sourceId) => _$this._sourceId = sourceId;

  String? _targetOwnerId;
  String? get targetOwnerId => _$this._targetOwnerId;
  set targetOwnerId(String? targetOwnerId) =>
      _$this._targetOwnerId = targetOwnerId;

  GCloneProjectInputBuilder();

  GCloneProjectInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _includeWorkflows = $v.includeWorkflows;
      _name = $v.name;
      _public = $v.public;
      _sourceId = $v.sourceId;
      _targetOwnerId = $v.targetOwnerId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCloneProjectInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCloneProjectInput;
  }

  @override
  void update(void Function(GCloneProjectInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCloneProjectInput build() {
    final _$result = _$v ??
        new _$GCloneProjectInput._(
            body: body,
            clientMutationId: clientMutationId,
            includeWorkflows: BuiltValueNullFieldError.checkNotNull(
                includeWorkflows, 'GCloneProjectInput', 'includeWorkflows'),
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GCloneProjectInput', 'name'),
            public: public,
            sourceId: BuiltValueNullFieldError.checkNotNull(
                sourceId, 'GCloneProjectInput', 'sourceId'),
            targetOwnerId: BuiltValueNullFieldError.checkNotNull(
                targetOwnerId, 'GCloneProjectInput', 'targetOwnerId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCloneTemplateRepositoryInput extends GCloneTemplateRepositoryInput {
  @override
  final String? clientMutationId;
  @override
  final String? description;
  @override
  final bool? includeAllBranches;
  @override
  final String name;
  @override
  final String ownerId;
  @override
  final String repositoryId;
  @override
  final GRepositoryVisibility visibility;

  factory _$GCloneTemplateRepositoryInput(
          [void Function(GCloneTemplateRepositoryInputBuilder)? updates]) =>
      (new GCloneTemplateRepositoryInputBuilder()..update(updates)).build();

  _$GCloneTemplateRepositoryInput._(
      {this.clientMutationId,
      this.description,
      this.includeAllBranches,
      required this.name,
      required this.ownerId,
      required this.repositoryId,
      required this.visibility})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        name, 'GCloneTemplateRepositoryInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        ownerId, 'GCloneTemplateRepositoryInput', 'ownerId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCloneTemplateRepositoryInput', 'repositoryId');
    BuiltValueNullFieldError.checkNotNull(
        visibility, 'GCloneTemplateRepositoryInput', 'visibility');
  }

  @override
  GCloneTemplateRepositoryInput rebuild(
          void Function(GCloneTemplateRepositoryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCloneTemplateRepositoryInputBuilder toBuilder() =>
      new GCloneTemplateRepositoryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCloneTemplateRepositoryInput &&
        clientMutationId == other.clientMutationId &&
        description == other.description &&
        includeAllBranches == other.includeAllBranches &&
        name == other.name &&
        ownerId == other.ownerId &&
        repositoryId == other.repositoryId &&
        visibility == other.visibility;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc($jc(0, clientMutationId.hashCode),
                            description.hashCode),
                        includeAllBranches.hashCode),
                    name.hashCode),
                ownerId.hashCode),
            repositoryId.hashCode),
        visibility.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCloneTemplateRepositoryInput')
          ..add('clientMutationId', clientMutationId)
          ..add('description', description)
          ..add('includeAllBranches', includeAllBranches)
          ..add('name', name)
          ..add('ownerId', ownerId)
          ..add('repositoryId', repositoryId)
          ..add('visibility', visibility))
        .toString();
  }
}

class GCloneTemplateRepositoryInputBuilder
    implements
        Builder<GCloneTemplateRepositoryInput,
            GCloneTemplateRepositoryInputBuilder> {
  _$GCloneTemplateRepositoryInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _description;
  String? get description => _$this._description;
  set description(String? description) => _$this._description = description;

  bool? _includeAllBranches;
  bool? get includeAllBranches => _$this._includeAllBranches;
  set includeAllBranches(bool? includeAllBranches) =>
      _$this._includeAllBranches = includeAllBranches;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _ownerId;
  String? get ownerId => _$this._ownerId;
  set ownerId(String? ownerId) => _$this._ownerId = ownerId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GRepositoryVisibility? _visibility;
  GRepositoryVisibility? get visibility => _$this._visibility;
  set visibility(GRepositoryVisibility? visibility) =>
      _$this._visibility = visibility;

  GCloneTemplateRepositoryInputBuilder();

  GCloneTemplateRepositoryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _description = $v.description;
      _includeAllBranches = $v.includeAllBranches;
      _name = $v.name;
      _ownerId = $v.ownerId;
      _repositoryId = $v.repositoryId;
      _visibility = $v.visibility;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCloneTemplateRepositoryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCloneTemplateRepositoryInput;
  }

  @override
  void update(void Function(GCloneTemplateRepositoryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCloneTemplateRepositoryInput build() {
    final _$result = _$v ??
        new _$GCloneTemplateRepositoryInput._(
            clientMutationId: clientMutationId,
            description: description,
            includeAllBranches: includeAllBranches,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GCloneTemplateRepositoryInput', 'name'),
            ownerId: BuiltValueNullFieldError.checkNotNull(
                ownerId, 'GCloneTemplateRepositoryInput', 'ownerId'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GCloneTemplateRepositoryInput', 'repositoryId'),
            visibility: BuiltValueNullFieldError.checkNotNull(
                visibility, 'GCloneTemplateRepositoryInput', 'visibility'));
    replace(_$result);
    return _$result;
  }
}

class _$GCloseIssueInput extends GCloseIssueInput {
  @override
  final String? clientMutationId;
  @override
  final String issueId;

  factory _$GCloseIssueInput(
          [void Function(GCloseIssueInputBuilder)? updates]) =>
      (new GCloseIssueInputBuilder()..update(updates)).build();

  _$GCloseIssueInput._({this.clientMutationId, required this.issueId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        issueId, 'GCloseIssueInput', 'issueId');
  }

  @override
  GCloseIssueInput rebuild(void Function(GCloseIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCloseIssueInputBuilder toBuilder() =>
      new GCloseIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCloseIssueInput &&
        clientMutationId == other.clientMutationId &&
        issueId == other.issueId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), issueId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCloseIssueInput')
          ..add('clientMutationId', clientMutationId)
          ..add('issueId', issueId))
        .toString();
  }
}

class GCloseIssueInputBuilder
    implements Builder<GCloseIssueInput, GCloseIssueInputBuilder> {
  _$GCloseIssueInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _issueId;
  String? get issueId => _$this._issueId;
  set issueId(String? issueId) => _$this._issueId = issueId;

  GCloseIssueInputBuilder();

  GCloseIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _issueId = $v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCloseIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCloseIssueInput;
  }

  @override
  void update(void Function(GCloseIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCloseIssueInput build() {
    final _$result = _$v ??
        new _$GCloseIssueInput._(
            clientMutationId: clientMutationId,
            issueId: BuiltValueNullFieldError.checkNotNull(
                issueId, 'GCloseIssueInput', 'issueId'));
    replace(_$result);
    return _$result;
  }
}

class _$GClosePullRequestInput extends GClosePullRequestInput {
  @override
  final String? clientMutationId;
  @override
  final String pullRequestId;

  factory _$GClosePullRequestInput(
          [void Function(GClosePullRequestInputBuilder)? updates]) =>
      (new GClosePullRequestInputBuilder()..update(updates)).build();

  _$GClosePullRequestInput._(
      {this.clientMutationId, required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GClosePullRequestInput', 'pullRequestId');
  }

  @override
  GClosePullRequestInput rebuild(
          void Function(GClosePullRequestInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GClosePullRequestInputBuilder toBuilder() =>
      new GClosePullRequestInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GClosePullRequestInput &&
        clientMutationId == other.clientMutationId &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GClosePullRequestInput')
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GClosePullRequestInputBuilder
    implements Builder<GClosePullRequestInput, GClosePullRequestInputBuilder> {
  _$GClosePullRequestInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GClosePullRequestInputBuilder();

  GClosePullRequestInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GClosePullRequestInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GClosePullRequestInput;
  }

  @override
  void update(void Function(GClosePullRequestInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GClosePullRequestInput build() {
    final _$result = _$v ??
        new _$GClosePullRequestInput._(
            clientMutationId: clientMutationId,
            pullRequestId: BuiltValueNullFieldError.checkNotNull(
                pullRequestId, 'GClosePullRequestInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCommitAuthor extends GCommitAuthor {
  @override
  final BuiltList<String>? emails;
  @override
  final String? id;

  factory _$GCommitAuthor([void Function(GCommitAuthorBuilder)? updates]) =>
      (new GCommitAuthorBuilder()..update(updates)).build();

  _$GCommitAuthor._({this.emails, this.id}) : super._();

  @override
  GCommitAuthor rebuild(void Function(GCommitAuthorBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCommitAuthorBuilder toBuilder() => new GCommitAuthorBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCommitAuthor && emails == other.emails && id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, emails.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCommitAuthor')
          ..add('emails', emails)
          ..add('id', id))
        .toString();
  }
}

class GCommitAuthorBuilder
    implements Builder<GCommitAuthor, GCommitAuthorBuilder> {
  _$GCommitAuthor? _$v;

  ListBuilder<String>? _emails;
  ListBuilder<String> get emails =>
      _$this._emails ??= new ListBuilder<String>();
  set emails(ListBuilder<String>? emails) => _$this._emails = emails;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GCommitAuthorBuilder();

  GCommitAuthorBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _emails = $v.emails?.toBuilder();
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCommitAuthor other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCommitAuthor;
  }

  @override
  void update(void Function(GCommitAuthorBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCommitAuthor build() {
    _$GCommitAuthor _$result;
    try {
      _$result = _$v ?? new _$GCommitAuthor._(emails: _emails?.build(), id: id);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'emails';
        _emails?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCommitAuthor', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCommitContributionOrder extends GCommitContributionOrder {
  @override
  final GOrderDirection direction;
  @override
  final GCommitContributionOrderField field;

  factory _$GCommitContributionOrder(
          [void Function(GCommitContributionOrderBuilder)? updates]) =>
      (new GCommitContributionOrderBuilder()..update(updates)).build();

  _$GCommitContributionOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GCommitContributionOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GCommitContributionOrder', 'field');
  }

  @override
  GCommitContributionOrder rebuild(
          void Function(GCommitContributionOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCommitContributionOrderBuilder toBuilder() =>
      new GCommitContributionOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCommitContributionOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCommitContributionOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GCommitContributionOrderBuilder
    implements
        Builder<GCommitContributionOrder, GCommitContributionOrderBuilder> {
  _$GCommitContributionOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GCommitContributionOrderField? _field;
  GCommitContributionOrderField? get field => _$this._field;
  set field(GCommitContributionOrderField? field) => _$this._field = field;

  GCommitContributionOrderBuilder();

  GCommitContributionOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCommitContributionOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCommitContributionOrder;
  }

  @override
  void update(void Function(GCommitContributionOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCommitContributionOrder build() {
    final _$result = _$v ??
        new _$GCommitContributionOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GCommitContributionOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GCommitContributionOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GContributionOrder extends GContributionOrder {
  @override
  final GOrderDirection direction;

  factory _$GContributionOrder(
          [void Function(GContributionOrderBuilder)? updates]) =>
      (new GContributionOrderBuilder()..update(updates)).build();

  _$GContributionOrder._({required this.direction}) : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GContributionOrder', 'direction');
  }

  @override
  GContributionOrder rebuild(
          void Function(GContributionOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GContributionOrderBuilder toBuilder() =>
      new GContributionOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GContributionOrder && direction == other.direction;
  }

  @override
  int get hashCode {
    return $jf($jc(0, direction.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GContributionOrder')
          ..add('direction', direction))
        .toString();
  }
}

class GContributionOrderBuilder
    implements Builder<GContributionOrder, GContributionOrderBuilder> {
  _$GContributionOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GContributionOrderBuilder();

  GContributionOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GContributionOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GContributionOrder;
  }

  @override
  void update(void Function(GContributionOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GContributionOrder build() {
    final _$result = _$v ??
        new _$GContributionOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GContributionOrder', 'direction'));
    replace(_$result);
    return _$result;
  }
}

class _$GConvertProjectCardNoteToIssueInput
    extends GConvertProjectCardNoteToIssueInput {
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final String projectCardId;
  @override
  final String repositoryId;
  @override
  final String? title;

  factory _$GConvertProjectCardNoteToIssueInput(
          [void Function(GConvertProjectCardNoteToIssueInputBuilder)?
              updates]) =>
      (new GConvertProjectCardNoteToIssueInputBuilder()..update(updates))
          .build();

  _$GConvertProjectCardNoteToIssueInput._(
      {this.body,
      this.clientMutationId,
      required this.projectCardId,
      required this.repositoryId,
      this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        projectCardId, 'GConvertProjectCardNoteToIssueInput', 'projectCardId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GConvertProjectCardNoteToIssueInput', 'repositoryId');
  }

  @override
  GConvertProjectCardNoteToIssueInput rebuild(
          void Function(GConvertProjectCardNoteToIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GConvertProjectCardNoteToIssueInputBuilder toBuilder() =>
      new GConvertProjectCardNoteToIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GConvertProjectCardNoteToIssueInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        projectCardId == other.projectCardId &&
        repositoryId == other.repositoryId &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
                projectCardId.hashCode),
            repositoryId.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GConvertProjectCardNoteToIssueInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('projectCardId', projectCardId)
          ..add('repositoryId', repositoryId)
          ..add('title', title))
        .toString();
  }
}

class GConvertProjectCardNoteToIssueInputBuilder
    implements
        Builder<GConvertProjectCardNoteToIssueInput,
            GConvertProjectCardNoteToIssueInputBuilder> {
  _$GConvertProjectCardNoteToIssueInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _projectCardId;
  String? get projectCardId => _$this._projectCardId;
  set projectCardId(String? projectCardId) =>
      _$this._projectCardId = projectCardId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GConvertProjectCardNoteToIssueInputBuilder();

  GConvertProjectCardNoteToIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _projectCardId = $v.projectCardId;
      _repositoryId = $v.repositoryId;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GConvertProjectCardNoteToIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GConvertProjectCardNoteToIssueInput;
  }

  @override
  void update(
      void Function(GConvertProjectCardNoteToIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GConvertProjectCardNoteToIssueInput build() {
    final _$result = _$v ??
        new _$GConvertProjectCardNoteToIssueInput._(
            body: body,
            clientMutationId: clientMutationId,
            projectCardId: BuiltValueNullFieldError.checkNotNull(projectCardId,
                'GConvertProjectCardNoteToIssueInput', 'projectCardId'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(repositoryId,
                'GConvertProjectCardNoteToIssueInput', 'repositoryId'),
            title: title);
    replace(_$result);
    return _$result;
  }
}

class _$GConvertPullRequestToDraftInput
    extends GConvertPullRequestToDraftInput {
  @override
  final String? clientMutationId;
  @override
  final String pullRequestId;

  factory _$GConvertPullRequestToDraftInput(
          [void Function(GConvertPullRequestToDraftInputBuilder)? updates]) =>
      (new GConvertPullRequestToDraftInputBuilder()..update(updates)).build();

  _$GConvertPullRequestToDraftInput._(
      {this.clientMutationId, required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GConvertPullRequestToDraftInput', 'pullRequestId');
  }

  @override
  GConvertPullRequestToDraftInput rebuild(
          void Function(GConvertPullRequestToDraftInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GConvertPullRequestToDraftInputBuilder toBuilder() =>
      new GConvertPullRequestToDraftInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GConvertPullRequestToDraftInput &&
        clientMutationId == other.clientMutationId &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GConvertPullRequestToDraftInput')
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GConvertPullRequestToDraftInputBuilder
    implements
        Builder<GConvertPullRequestToDraftInput,
            GConvertPullRequestToDraftInputBuilder> {
  _$GConvertPullRequestToDraftInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GConvertPullRequestToDraftInputBuilder();

  GConvertPullRequestToDraftInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GConvertPullRequestToDraftInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GConvertPullRequestToDraftInput;
  }

  @override
  void update(void Function(GConvertPullRequestToDraftInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GConvertPullRequestToDraftInput build() {
    final _$result = _$v ??
        new _$GConvertPullRequestToDraftInput._(
            clientMutationId: clientMutationId,
            pullRequestId: BuiltValueNullFieldError.checkNotNull(pullRequestId,
                'GConvertPullRequestToDraftInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateBranchProtectionRuleInput
    extends GCreateBranchProtectionRuleInput {
  @override
  final bool? allowsDeletions;
  @override
  final bool? allowsForcePushes;
  @override
  final String? clientMutationId;
  @override
  final bool? dismissesStaleReviews;
  @override
  final bool? isAdminEnforced;
  @override
  final String pattern;
  @override
  final BuiltList<String>? pushActorIds;
  @override
  final String repositoryId;
  @override
  final int? requiredApprovingReviewCount;
  @override
  final BuiltList<String>? requiredStatusCheckContexts;
  @override
  final bool? requiresApprovingReviews;
  @override
  final bool? requiresCodeOwnerReviews;
  @override
  final bool? requiresCommitSignatures;
  @override
  final bool? requiresLinearHistory;
  @override
  final bool? requiresStatusChecks;
  @override
  final bool? requiresStrictStatusChecks;
  @override
  final bool? restrictsPushes;
  @override
  final bool? restrictsReviewDismissals;
  @override
  final BuiltList<String>? reviewDismissalActorIds;

  factory _$GCreateBranchProtectionRuleInput(
          [void Function(GCreateBranchProtectionRuleInputBuilder)? updates]) =>
      (new GCreateBranchProtectionRuleInputBuilder()..update(updates)).build();

  _$GCreateBranchProtectionRuleInput._(
      {this.allowsDeletions,
      this.allowsForcePushes,
      this.clientMutationId,
      this.dismissesStaleReviews,
      this.isAdminEnforced,
      required this.pattern,
      this.pushActorIds,
      required this.repositoryId,
      this.requiredApprovingReviewCount,
      this.requiredStatusCheckContexts,
      this.requiresApprovingReviews,
      this.requiresCodeOwnerReviews,
      this.requiresCommitSignatures,
      this.requiresLinearHistory,
      this.requiresStatusChecks,
      this.requiresStrictStatusChecks,
      this.restrictsPushes,
      this.restrictsReviewDismissals,
      this.reviewDismissalActorIds})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pattern, 'GCreateBranchProtectionRuleInput', 'pattern');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreateBranchProtectionRuleInput', 'repositoryId');
  }

  @override
  GCreateBranchProtectionRuleInput rebuild(
          void Function(GCreateBranchProtectionRuleInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateBranchProtectionRuleInputBuilder toBuilder() =>
      new GCreateBranchProtectionRuleInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateBranchProtectionRuleInput &&
        allowsDeletions == other.allowsDeletions &&
        allowsForcePushes == other.allowsForcePushes &&
        clientMutationId == other.clientMutationId &&
        dismissesStaleReviews == other.dismissesStaleReviews &&
        isAdminEnforced == other.isAdminEnforced &&
        pattern == other.pattern &&
        pushActorIds == other.pushActorIds &&
        repositoryId == other.repositoryId &&
        requiredApprovingReviewCount == other.requiredApprovingReviewCount &&
        requiredStatusCheckContexts == other.requiredStatusCheckContexts &&
        requiresApprovingReviews == other.requiresApprovingReviews &&
        requiresCodeOwnerReviews == other.requiresCodeOwnerReviews &&
        requiresCommitSignatures == other.requiresCommitSignatures &&
        requiresLinearHistory == other.requiresLinearHistory &&
        requiresStatusChecks == other.requiresStatusChecks &&
        requiresStrictStatusChecks == other.requiresStrictStatusChecks &&
        restrictsPushes == other.restrictsPushes &&
        restrictsReviewDismissals == other.restrictsReviewDismissals &&
        reviewDismissalActorIds == other.reviewDismissalActorIds;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc(
                                    $jc(
                                        $jc(
                                            $jc(
                                                $jc(
                                                    $jc(
                                                        $jc(
                                                            $jc(
                                                                $jc(
                                                                    $jc(
                                                                        $jc(
                                                                            $jc(
                                                                                0,
                                                                                allowsDeletions
                                                                                    .hashCode),
                                                                            allowsForcePushes
                                                                                .hashCode),
                                                                        clientMutationId
                                                                            .hashCode),
                                                                    dismissesStaleReviews
                                                                        .hashCode),
                                                                isAdminEnforced
                                                                    .hashCode),
                                                            pattern.hashCode),
                                                        pushActorIds.hashCode),
                                                    repositoryId.hashCode),
                                                requiredApprovingReviewCount
                                                    .hashCode),
                                            requiredStatusCheckContexts
                                                .hashCode),
                                        requiresApprovingReviews.hashCode),
                                    requiresCodeOwnerReviews.hashCode),
                                requiresCommitSignatures.hashCode),
                            requiresLinearHistory.hashCode),
                        requiresStatusChecks.hashCode),
                    requiresStrictStatusChecks.hashCode),
                restrictsPushes.hashCode),
            restrictsReviewDismissals.hashCode),
        reviewDismissalActorIds.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateBranchProtectionRuleInput')
          ..add('allowsDeletions', allowsDeletions)
          ..add('allowsForcePushes', allowsForcePushes)
          ..add('clientMutationId', clientMutationId)
          ..add('dismissesStaleReviews', dismissesStaleReviews)
          ..add('isAdminEnforced', isAdminEnforced)
          ..add('pattern', pattern)
          ..add('pushActorIds', pushActorIds)
          ..add('repositoryId', repositoryId)
          ..add('requiredApprovingReviewCount', requiredApprovingReviewCount)
          ..add('requiredStatusCheckContexts', requiredStatusCheckContexts)
          ..add('requiresApprovingReviews', requiresApprovingReviews)
          ..add('requiresCodeOwnerReviews', requiresCodeOwnerReviews)
          ..add('requiresCommitSignatures', requiresCommitSignatures)
          ..add('requiresLinearHistory', requiresLinearHistory)
          ..add('requiresStatusChecks', requiresStatusChecks)
          ..add('requiresStrictStatusChecks', requiresStrictStatusChecks)
          ..add('restrictsPushes', restrictsPushes)
          ..add('restrictsReviewDismissals', restrictsReviewDismissals)
          ..add('reviewDismissalActorIds', reviewDismissalActorIds))
        .toString();
  }
}

class GCreateBranchProtectionRuleInputBuilder
    implements
        Builder<GCreateBranchProtectionRuleInput,
            GCreateBranchProtectionRuleInputBuilder> {
  _$GCreateBranchProtectionRuleInput? _$v;

  bool? _allowsDeletions;
  bool? get allowsDeletions => _$this._allowsDeletions;
  set allowsDeletions(bool? allowsDeletions) =>
      _$this._allowsDeletions = allowsDeletions;

  bool? _allowsForcePushes;
  bool? get allowsForcePushes => _$this._allowsForcePushes;
  set allowsForcePushes(bool? allowsForcePushes) =>
      _$this._allowsForcePushes = allowsForcePushes;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _dismissesStaleReviews;
  bool? get dismissesStaleReviews => _$this._dismissesStaleReviews;
  set dismissesStaleReviews(bool? dismissesStaleReviews) =>
      _$this._dismissesStaleReviews = dismissesStaleReviews;

  bool? _isAdminEnforced;
  bool? get isAdminEnforced => _$this._isAdminEnforced;
  set isAdminEnforced(bool? isAdminEnforced) =>
      _$this._isAdminEnforced = isAdminEnforced;

  String? _pattern;
  String? get pattern => _$this._pattern;
  set pattern(String? pattern) => _$this._pattern = pattern;

  ListBuilder<String>? _pushActorIds;
  ListBuilder<String> get pushActorIds =>
      _$this._pushActorIds ??= new ListBuilder<String>();
  set pushActorIds(ListBuilder<String>? pushActorIds) =>
      _$this._pushActorIds = pushActorIds;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  int? _requiredApprovingReviewCount;
  int? get requiredApprovingReviewCount => _$this._requiredApprovingReviewCount;
  set requiredApprovingReviewCount(int? requiredApprovingReviewCount) =>
      _$this._requiredApprovingReviewCount = requiredApprovingReviewCount;

  ListBuilder<String>? _requiredStatusCheckContexts;
  ListBuilder<String> get requiredStatusCheckContexts =>
      _$this._requiredStatusCheckContexts ??= new ListBuilder<String>();
  set requiredStatusCheckContexts(
          ListBuilder<String>? requiredStatusCheckContexts) =>
      _$this._requiredStatusCheckContexts = requiredStatusCheckContexts;

  bool? _requiresApprovingReviews;
  bool? get requiresApprovingReviews => _$this._requiresApprovingReviews;
  set requiresApprovingReviews(bool? requiresApprovingReviews) =>
      _$this._requiresApprovingReviews = requiresApprovingReviews;

  bool? _requiresCodeOwnerReviews;
  bool? get requiresCodeOwnerReviews => _$this._requiresCodeOwnerReviews;
  set requiresCodeOwnerReviews(bool? requiresCodeOwnerReviews) =>
      _$this._requiresCodeOwnerReviews = requiresCodeOwnerReviews;

  bool? _requiresCommitSignatures;
  bool? get requiresCommitSignatures => _$this._requiresCommitSignatures;
  set requiresCommitSignatures(bool? requiresCommitSignatures) =>
      _$this._requiresCommitSignatures = requiresCommitSignatures;

  bool? _requiresLinearHistory;
  bool? get requiresLinearHistory => _$this._requiresLinearHistory;
  set requiresLinearHistory(bool? requiresLinearHistory) =>
      _$this._requiresLinearHistory = requiresLinearHistory;

  bool? _requiresStatusChecks;
  bool? get requiresStatusChecks => _$this._requiresStatusChecks;
  set requiresStatusChecks(bool? requiresStatusChecks) =>
      _$this._requiresStatusChecks = requiresStatusChecks;

  bool? _requiresStrictStatusChecks;
  bool? get requiresStrictStatusChecks => _$this._requiresStrictStatusChecks;
  set requiresStrictStatusChecks(bool? requiresStrictStatusChecks) =>
      _$this._requiresStrictStatusChecks = requiresStrictStatusChecks;

  bool? _restrictsPushes;
  bool? get restrictsPushes => _$this._restrictsPushes;
  set restrictsPushes(bool? restrictsPushes) =>
      _$this._restrictsPushes = restrictsPushes;

  bool? _restrictsReviewDismissals;
  bool? get restrictsReviewDismissals => _$this._restrictsReviewDismissals;
  set restrictsReviewDismissals(bool? restrictsReviewDismissals) =>
      _$this._restrictsReviewDismissals = restrictsReviewDismissals;

  ListBuilder<String>? _reviewDismissalActorIds;
  ListBuilder<String> get reviewDismissalActorIds =>
      _$this._reviewDismissalActorIds ??= new ListBuilder<String>();
  set reviewDismissalActorIds(ListBuilder<String>? reviewDismissalActorIds) =>
      _$this._reviewDismissalActorIds = reviewDismissalActorIds;

  GCreateBranchProtectionRuleInputBuilder();

  GCreateBranchProtectionRuleInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _allowsDeletions = $v.allowsDeletions;
      _allowsForcePushes = $v.allowsForcePushes;
      _clientMutationId = $v.clientMutationId;
      _dismissesStaleReviews = $v.dismissesStaleReviews;
      _isAdminEnforced = $v.isAdminEnforced;
      _pattern = $v.pattern;
      _pushActorIds = $v.pushActorIds?.toBuilder();
      _repositoryId = $v.repositoryId;
      _requiredApprovingReviewCount = $v.requiredApprovingReviewCount;
      _requiredStatusCheckContexts =
          $v.requiredStatusCheckContexts?.toBuilder();
      _requiresApprovingReviews = $v.requiresApprovingReviews;
      _requiresCodeOwnerReviews = $v.requiresCodeOwnerReviews;
      _requiresCommitSignatures = $v.requiresCommitSignatures;
      _requiresLinearHistory = $v.requiresLinearHistory;
      _requiresStatusChecks = $v.requiresStatusChecks;
      _requiresStrictStatusChecks = $v.requiresStrictStatusChecks;
      _restrictsPushes = $v.restrictsPushes;
      _restrictsReviewDismissals = $v.restrictsReviewDismissals;
      _reviewDismissalActorIds = $v.reviewDismissalActorIds?.toBuilder();
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateBranchProtectionRuleInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateBranchProtectionRuleInput;
  }

  @override
  void update(void Function(GCreateBranchProtectionRuleInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateBranchProtectionRuleInput build() {
    _$GCreateBranchProtectionRuleInput _$result;
    try {
      _$result = _$v ??
          new _$GCreateBranchProtectionRuleInput._(
              allowsDeletions: allowsDeletions,
              allowsForcePushes: allowsForcePushes,
              clientMutationId: clientMutationId,
              dismissesStaleReviews: dismissesStaleReviews,
              isAdminEnforced: isAdminEnforced,
              pattern: BuiltValueNullFieldError.checkNotNull(
                  pattern, 'GCreateBranchProtectionRuleInput', 'pattern'),
              pushActorIds: _pushActorIds?.build(),
              repositoryId: BuiltValueNullFieldError.checkNotNull(repositoryId,
                  'GCreateBranchProtectionRuleInput', 'repositoryId'),
              requiredApprovingReviewCount: requiredApprovingReviewCount,
              requiredStatusCheckContexts:
                  _requiredStatusCheckContexts?.build(),
              requiresApprovingReviews: requiresApprovingReviews,
              requiresCodeOwnerReviews: requiresCodeOwnerReviews,
              requiresCommitSignatures: requiresCommitSignatures,
              requiresLinearHistory: requiresLinearHistory,
              requiresStatusChecks: requiresStatusChecks,
              requiresStrictStatusChecks: requiresStrictStatusChecks,
              restrictsPushes: restrictsPushes,
              restrictsReviewDismissals: restrictsReviewDismissals,
              reviewDismissalActorIds: _reviewDismissalActorIds?.build());
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'pushActorIds';
        _pushActorIds?.build();

        _$failedField = 'requiredStatusCheckContexts';
        _requiredStatusCheckContexts?.build();

        _$failedField = 'reviewDismissalActorIds';
        _reviewDismissalActorIds?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCreateBranchProtectionRuleInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCreateCheckRunInput extends GCreateCheckRunInput {
  @override
  final BuiltList<GCheckRunAction>? actions;
  @override
  final String? clientMutationId;
  @override
  final DateTime? completedAt;
  @override
  final GCheckConclusionState? conclusion;
  @override
  final String? detailsUrl;
  @override
  final String? externalId;
  @override
  final String headSha;
  @override
  final String name;
  @override
  final GCheckRunOutput? output;
  @override
  final String repositoryId;
  @override
  final DateTime? startedAt;
  @override
  final GRequestableCheckStatusState? status;

  factory _$GCreateCheckRunInput(
          [void Function(GCreateCheckRunInputBuilder)? updates]) =>
      (new GCreateCheckRunInputBuilder()..update(updates)).build();

  _$GCreateCheckRunInput._(
      {this.actions,
      this.clientMutationId,
      this.completedAt,
      this.conclusion,
      this.detailsUrl,
      this.externalId,
      required this.headSha,
      required this.name,
      this.output,
      required this.repositoryId,
      this.startedAt,
      this.status})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        headSha, 'GCreateCheckRunInput', 'headSha');
    BuiltValueNullFieldError.checkNotNull(name, 'GCreateCheckRunInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreateCheckRunInput', 'repositoryId');
  }

  @override
  GCreateCheckRunInput rebuild(
          void Function(GCreateCheckRunInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateCheckRunInputBuilder toBuilder() =>
      new GCreateCheckRunInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateCheckRunInput &&
        actions == other.actions &&
        clientMutationId == other.clientMutationId &&
        completedAt == other.completedAt &&
        conclusion == other.conclusion &&
        detailsUrl == other.detailsUrl &&
        externalId == other.externalId &&
        headSha == other.headSha &&
        name == other.name &&
        output == other.output &&
        repositoryId == other.repositoryId &&
        startedAt == other.startedAt &&
        status == other.status;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc(
                                    $jc(
                                        $jc(
                                            $jc($jc(0, actions.hashCode),
                                                clientMutationId.hashCode),
                                            completedAt.hashCode),
                                        conclusion.hashCode),
                                    detailsUrl.hashCode),
                                externalId.hashCode),
                            headSha.hashCode),
                        name.hashCode),
                    output.hashCode),
                repositoryId.hashCode),
            startedAt.hashCode),
        status.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateCheckRunInput')
          ..add('actions', actions)
          ..add('clientMutationId', clientMutationId)
          ..add('completedAt', completedAt)
          ..add('conclusion', conclusion)
          ..add('detailsUrl', detailsUrl)
          ..add('externalId', externalId)
          ..add('headSha', headSha)
          ..add('name', name)
          ..add('output', output)
          ..add('repositoryId', repositoryId)
          ..add('startedAt', startedAt)
          ..add('status', status))
        .toString();
  }
}

class GCreateCheckRunInputBuilder
    implements Builder<GCreateCheckRunInput, GCreateCheckRunInputBuilder> {
  _$GCreateCheckRunInput? _$v;

  ListBuilder<GCheckRunAction>? _actions;
  ListBuilder<GCheckRunAction> get actions =>
      _$this._actions ??= new ListBuilder<GCheckRunAction>();
  set actions(ListBuilder<GCheckRunAction>? actions) =>
      _$this._actions = actions;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  DateTime? _completedAt;
  DateTime? get completedAt => _$this._completedAt;
  set completedAt(DateTime? completedAt) => _$this._completedAt = completedAt;

  GCheckConclusionState? _conclusion;
  GCheckConclusionState? get conclusion => _$this._conclusion;
  set conclusion(GCheckConclusionState? conclusion) =>
      _$this._conclusion = conclusion;

  String? _detailsUrl;
  String? get detailsUrl => _$this._detailsUrl;
  set detailsUrl(String? detailsUrl) => _$this._detailsUrl = detailsUrl;

  String? _externalId;
  String? get externalId => _$this._externalId;
  set externalId(String? externalId) => _$this._externalId = externalId;

  String? _headSha;
  String? get headSha => _$this._headSha;
  set headSha(String? headSha) => _$this._headSha = headSha;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  GCheckRunOutputBuilder? _output;
  GCheckRunOutputBuilder get output =>
      _$this._output ??= new GCheckRunOutputBuilder();
  set output(GCheckRunOutputBuilder? output) => _$this._output = output;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  DateTime? _startedAt;
  DateTime? get startedAt => _$this._startedAt;
  set startedAt(DateTime? startedAt) => _$this._startedAt = startedAt;

  GRequestableCheckStatusState? _status;
  GRequestableCheckStatusState? get status => _$this._status;
  set status(GRequestableCheckStatusState? status) => _$this._status = status;

  GCreateCheckRunInputBuilder();

  GCreateCheckRunInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _actions = $v.actions?.toBuilder();
      _clientMutationId = $v.clientMutationId;
      _completedAt = $v.completedAt;
      _conclusion = $v.conclusion;
      _detailsUrl = $v.detailsUrl;
      _externalId = $v.externalId;
      _headSha = $v.headSha;
      _name = $v.name;
      _output = $v.output?.toBuilder();
      _repositoryId = $v.repositoryId;
      _startedAt = $v.startedAt;
      _status = $v.status;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateCheckRunInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateCheckRunInput;
  }

  @override
  void update(void Function(GCreateCheckRunInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateCheckRunInput build() {
    _$GCreateCheckRunInput _$result;
    try {
      _$result = _$v ??
          new _$GCreateCheckRunInput._(
              actions: _actions?.build(),
              clientMutationId: clientMutationId,
              completedAt: completedAt,
              conclusion: conclusion,
              detailsUrl: detailsUrl,
              externalId: externalId,
              headSha: BuiltValueNullFieldError.checkNotNull(
                  headSha, 'GCreateCheckRunInput', 'headSha'),
              name: BuiltValueNullFieldError.checkNotNull(
                  name, 'GCreateCheckRunInput', 'name'),
              output: _output?.build(),
              repositoryId: BuiltValueNullFieldError.checkNotNull(
                  repositoryId, 'GCreateCheckRunInput', 'repositoryId'),
              startedAt: startedAt,
              status: status);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'actions';
        _actions?.build();

        _$failedField = 'output';
        _output?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCreateCheckRunInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCreateCheckSuiteInput extends GCreateCheckSuiteInput {
  @override
  final String? clientMutationId;
  @override
  final String headSha;
  @override
  final String repositoryId;

  factory _$GCreateCheckSuiteInput(
          [void Function(GCreateCheckSuiteInputBuilder)? updates]) =>
      (new GCreateCheckSuiteInputBuilder()..update(updates)).build();

  _$GCreateCheckSuiteInput._(
      {this.clientMutationId,
      required this.headSha,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        headSha, 'GCreateCheckSuiteInput', 'headSha');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreateCheckSuiteInput', 'repositoryId');
  }

  @override
  GCreateCheckSuiteInput rebuild(
          void Function(GCreateCheckSuiteInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateCheckSuiteInputBuilder toBuilder() =>
      new GCreateCheckSuiteInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateCheckSuiteInput &&
        clientMutationId == other.clientMutationId &&
        headSha == other.headSha &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), headSha.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateCheckSuiteInput')
          ..add('clientMutationId', clientMutationId)
          ..add('headSha', headSha)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GCreateCheckSuiteInputBuilder
    implements Builder<GCreateCheckSuiteInput, GCreateCheckSuiteInputBuilder> {
  _$GCreateCheckSuiteInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _headSha;
  String? get headSha => _$this._headSha;
  set headSha(String? headSha) => _$this._headSha = headSha;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GCreateCheckSuiteInputBuilder();

  GCreateCheckSuiteInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _headSha = $v.headSha;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateCheckSuiteInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateCheckSuiteInput;
  }

  @override
  void update(void Function(GCreateCheckSuiteInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateCheckSuiteInput build() {
    final _$result = _$v ??
        new _$GCreateCheckSuiteInput._(
            clientMutationId: clientMutationId,
            headSha: BuiltValueNullFieldError.checkNotNull(
                headSha, 'GCreateCheckSuiteInput', 'headSha'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GCreateCheckSuiteInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateDiscussionInput extends GCreateDiscussionInput {
  @override
  final String body;
  @override
  final String categoryId;
  @override
  final String? clientMutationId;
  @override
  final String repositoryId;
  @override
  final String title;

  factory _$GCreateDiscussionInput(
          [void Function(GCreateDiscussionInputBuilder)? updates]) =>
      (new GCreateDiscussionInputBuilder()..update(updates)).build();

  _$GCreateDiscussionInput._(
      {required this.body,
      required this.categoryId,
      this.clientMutationId,
      required this.repositoryId,
      required this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GCreateDiscussionInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        categoryId, 'GCreateDiscussionInput', 'categoryId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreateDiscussionInput', 'repositoryId');
    BuiltValueNullFieldError.checkNotNull(
        title, 'GCreateDiscussionInput', 'title');
  }

  @override
  GCreateDiscussionInput rebuild(
          void Function(GCreateDiscussionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateDiscussionInputBuilder toBuilder() =>
      new GCreateDiscussionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateDiscussionInput &&
        body == other.body &&
        categoryId == other.categoryId &&
        clientMutationId == other.clientMutationId &&
        repositoryId == other.repositoryId &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, body.hashCode), categoryId.hashCode),
                clientMutationId.hashCode),
            repositoryId.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateDiscussionInput')
          ..add('body', body)
          ..add('categoryId', categoryId)
          ..add('clientMutationId', clientMutationId)
          ..add('repositoryId', repositoryId)
          ..add('title', title))
        .toString();
  }
}

class GCreateDiscussionInputBuilder
    implements Builder<GCreateDiscussionInput, GCreateDiscussionInputBuilder> {
  _$GCreateDiscussionInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _categoryId;
  String? get categoryId => _$this._categoryId;
  set categoryId(String? categoryId) => _$this._categoryId = categoryId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GCreateDiscussionInputBuilder();

  GCreateDiscussionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _categoryId = $v.categoryId;
      _clientMutationId = $v.clientMutationId;
      _repositoryId = $v.repositoryId;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateDiscussionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateDiscussionInput;
  }

  @override
  void update(void Function(GCreateDiscussionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateDiscussionInput build() {
    final _$result = _$v ??
        new _$GCreateDiscussionInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GCreateDiscussionInput', 'body'),
            categoryId: BuiltValueNullFieldError.checkNotNull(
                categoryId, 'GCreateDiscussionInput', 'categoryId'),
            clientMutationId: clientMutationId,
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GCreateDiscussionInput', 'repositoryId'),
            title: BuiltValueNullFieldError.checkNotNull(
                title, 'GCreateDiscussionInput', 'title'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateEnterpriseOrganizationInput
    extends GCreateEnterpriseOrganizationInput {
  @override
  final BuiltList<String> adminLogins;
  @override
  final String billingEmail;
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final String login;
  @override
  final String profileName;

  factory _$GCreateEnterpriseOrganizationInput(
          [void Function(GCreateEnterpriseOrganizationInputBuilder)?
              updates]) =>
      (new GCreateEnterpriseOrganizationInputBuilder()..update(updates))
          .build();

  _$GCreateEnterpriseOrganizationInput._(
      {required this.adminLogins,
      required this.billingEmail,
      this.clientMutationId,
      required this.enterpriseId,
      required this.login,
      required this.profileName})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        adminLogins, 'GCreateEnterpriseOrganizationInput', 'adminLogins');
    BuiltValueNullFieldError.checkNotNull(
        billingEmail, 'GCreateEnterpriseOrganizationInput', 'billingEmail');
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GCreateEnterpriseOrganizationInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        login, 'GCreateEnterpriseOrganizationInput', 'login');
    BuiltValueNullFieldError.checkNotNull(
        profileName, 'GCreateEnterpriseOrganizationInput', 'profileName');
  }

  @override
  GCreateEnterpriseOrganizationInput rebuild(
          void Function(GCreateEnterpriseOrganizationInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateEnterpriseOrganizationInputBuilder toBuilder() =>
      new GCreateEnterpriseOrganizationInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateEnterpriseOrganizationInput &&
        adminLogins == other.adminLogins &&
        billingEmail == other.billingEmail &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        login == other.login &&
        profileName == other.profileName;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc($jc($jc(0, adminLogins.hashCode), billingEmail.hashCode),
                    clientMutationId.hashCode),
                enterpriseId.hashCode),
            login.hashCode),
        profileName.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateEnterpriseOrganizationInput')
          ..add('adminLogins', adminLogins)
          ..add('billingEmail', billingEmail)
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('login', login)
          ..add('profileName', profileName))
        .toString();
  }
}

class GCreateEnterpriseOrganizationInputBuilder
    implements
        Builder<GCreateEnterpriseOrganizationInput,
            GCreateEnterpriseOrganizationInputBuilder> {
  _$GCreateEnterpriseOrganizationInput? _$v;

  ListBuilder<String>? _adminLogins;
  ListBuilder<String> get adminLogins =>
      _$this._adminLogins ??= new ListBuilder<String>();
  set adminLogins(ListBuilder<String>? adminLogins) =>
      _$this._adminLogins = adminLogins;

  String? _billingEmail;
  String? get billingEmail => _$this._billingEmail;
  set billingEmail(String? billingEmail) => _$this._billingEmail = billingEmail;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _login;
  String? get login => _$this._login;
  set login(String? login) => _$this._login = login;

  String? _profileName;
  String? get profileName => _$this._profileName;
  set profileName(String? profileName) => _$this._profileName = profileName;

  GCreateEnterpriseOrganizationInputBuilder();

  GCreateEnterpriseOrganizationInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _adminLogins = $v.adminLogins.toBuilder();
      _billingEmail = $v.billingEmail;
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _login = $v.login;
      _profileName = $v.profileName;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateEnterpriseOrganizationInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateEnterpriseOrganizationInput;
  }

  @override
  void update(
      void Function(GCreateEnterpriseOrganizationInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateEnterpriseOrganizationInput build() {
    _$GCreateEnterpriseOrganizationInput _$result;
    try {
      _$result = _$v ??
          new _$GCreateEnterpriseOrganizationInput._(
              adminLogins: adminLogins.build(),
              billingEmail: BuiltValueNullFieldError.checkNotNull(billingEmail,
                  'GCreateEnterpriseOrganizationInput', 'billingEmail'),
              clientMutationId: clientMutationId,
              enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                  'GCreateEnterpriseOrganizationInput', 'enterpriseId'),
              login: BuiltValueNullFieldError.checkNotNull(
                  login, 'GCreateEnterpriseOrganizationInput', 'login'),
              profileName: BuiltValueNullFieldError.checkNotNull(profileName,
                  'GCreateEnterpriseOrganizationInput', 'profileName'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'adminLogins';
        adminLogins.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCreateEnterpriseOrganizationInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCreateEnvironmentInput extends GCreateEnvironmentInput {
  @override
  final String? clientMutationId;
  @override
  final String name;
  @override
  final String repositoryId;

  factory _$GCreateEnvironmentInput(
          [void Function(GCreateEnvironmentInputBuilder)? updates]) =>
      (new GCreateEnvironmentInputBuilder()..update(updates)).build();

  _$GCreateEnvironmentInput._(
      {this.clientMutationId, required this.name, required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        name, 'GCreateEnvironmentInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreateEnvironmentInput', 'repositoryId');
  }

  @override
  GCreateEnvironmentInput rebuild(
          void Function(GCreateEnvironmentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateEnvironmentInputBuilder toBuilder() =>
      new GCreateEnvironmentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateEnvironmentInput &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), name.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateEnvironmentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GCreateEnvironmentInputBuilder
    implements
        Builder<GCreateEnvironmentInput, GCreateEnvironmentInputBuilder> {
  _$GCreateEnvironmentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GCreateEnvironmentInputBuilder();

  GCreateEnvironmentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateEnvironmentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateEnvironmentInput;
  }

  @override
  void update(void Function(GCreateEnvironmentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateEnvironmentInput build() {
    final _$result = _$v ??
        new _$GCreateEnvironmentInput._(
            clientMutationId: clientMutationId,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GCreateEnvironmentInput', 'name'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GCreateEnvironmentInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateIpAllowListEntryInput extends GCreateIpAllowListEntryInput {
  @override
  final String allowListValue;
  @override
  final String? clientMutationId;
  @override
  final bool isActive;
  @override
  final String? name;
  @override
  final String ownerId;

  factory _$GCreateIpAllowListEntryInput(
          [void Function(GCreateIpAllowListEntryInputBuilder)? updates]) =>
      (new GCreateIpAllowListEntryInputBuilder()..update(updates)).build();

  _$GCreateIpAllowListEntryInput._(
      {required this.allowListValue,
      this.clientMutationId,
      required this.isActive,
      this.name,
      required this.ownerId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        allowListValue, 'GCreateIpAllowListEntryInput', 'allowListValue');
    BuiltValueNullFieldError.checkNotNull(
        isActive, 'GCreateIpAllowListEntryInput', 'isActive');
    BuiltValueNullFieldError.checkNotNull(
        ownerId, 'GCreateIpAllowListEntryInput', 'ownerId');
  }

  @override
  GCreateIpAllowListEntryInput rebuild(
          void Function(GCreateIpAllowListEntryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateIpAllowListEntryInputBuilder toBuilder() =>
      new GCreateIpAllowListEntryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateIpAllowListEntryInput &&
        allowListValue == other.allowListValue &&
        clientMutationId == other.clientMutationId &&
        isActive == other.isActive &&
        name == other.name &&
        ownerId == other.ownerId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, allowListValue.hashCode), clientMutationId.hashCode),
                isActive.hashCode),
            name.hashCode),
        ownerId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateIpAllowListEntryInput')
          ..add('allowListValue', allowListValue)
          ..add('clientMutationId', clientMutationId)
          ..add('isActive', isActive)
          ..add('name', name)
          ..add('ownerId', ownerId))
        .toString();
  }
}

class GCreateIpAllowListEntryInputBuilder
    implements
        Builder<GCreateIpAllowListEntryInput,
            GCreateIpAllowListEntryInputBuilder> {
  _$GCreateIpAllowListEntryInput? _$v;

  String? _allowListValue;
  String? get allowListValue => _$this._allowListValue;
  set allowListValue(String? allowListValue) =>
      _$this._allowListValue = allowListValue;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _isActive;
  bool? get isActive => _$this._isActive;
  set isActive(bool? isActive) => _$this._isActive = isActive;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _ownerId;
  String? get ownerId => _$this._ownerId;
  set ownerId(String? ownerId) => _$this._ownerId = ownerId;

  GCreateIpAllowListEntryInputBuilder();

  GCreateIpAllowListEntryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _allowListValue = $v.allowListValue;
      _clientMutationId = $v.clientMutationId;
      _isActive = $v.isActive;
      _name = $v.name;
      _ownerId = $v.ownerId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateIpAllowListEntryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateIpAllowListEntryInput;
  }

  @override
  void update(void Function(GCreateIpAllowListEntryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateIpAllowListEntryInput build() {
    final _$result = _$v ??
        new _$GCreateIpAllowListEntryInput._(
            allowListValue: BuiltValueNullFieldError.checkNotNull(
                allowListValue,
                'GCreateIpAllowListEntryInput',
                'allowListValue'),
            clientMutationId: clientMutationId,
            isActive: BuiltValueNullFieldError.checkNotNull(
                isActive, 'GCreateIpAllowListEntryInput', 'isActive'),
            name: name,
            ownerId: BuiltValueNullFieldError.checkNotNull(
                ownerId, 'GCreateIpAllowListEntryInput', 'ownerId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateIssueInput extends GCreateIssueInput {
  @override
  final BuiltList<String>? assigneeIds;
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final String? issueTemplate;
  @override
  final BuiltList<String>? labelIds;
  @override
  final String? milestoneId;
  @override
  final BuiltList<String>? projectIds;
  @override
  final String repositoryId;
  @override
  final String title;

  factory _$GCreateIssueInput(
          [void Function(GCreateIssueInputBuilder)? updates]) =>
      (new GCreateIssueInputBuilder()..update(updates)).build();

  _$GCreateIssueInput._(
      {this.assigneeIds,
      this.body,
      this.clientMutationId,
      this.issueTemplate,
      this.labelIds,
      this.milestoneId,
      this.projectIds,
      required this.repositoryId,
      required this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreateIssueInput', 'repositoryId');
    BuiltValueNullFieldError.checkNotNull(title, 'GCreateIssueInput', 'title');
  }

  @override
  GCreateIssueInput rebuild(void Function(GCreateIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateIssueInputBuilder toBuilder() =>
      new GCreateIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateIssueInput &&
        assigneeIds == other.assigneeIds &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        issueTemplate == other.issueTemplate &&
        labelIds == other.labelIds &&
        milestoneId == other.milestoneId &&
        projectIds == other.projectIds &&
        repositoryId == other.repositoryId &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc($jc(0, assigneeIds.hashCode),
                                    body.hashCode),
                                clientMutationId.hashCode),
                            issueTemplate.hashCode),
                        labelIds.hashCode),
                    milestoneId.hashCode),
                projectIds.hashCode),
            repositoryId.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateIssueInput')
          ..add('assigneeIds', assigneeIds)
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('issueTemplate', issueTemplate)
          ..add('labelIds', labelIds)
          ..add('milestoneId', milestoneId)
          ..add('projectIds', projectIds)
          ..add('repositoryId', repositoryId)
          ..add('title', title))
        .toString();
  }
}

class GCreateIssueInputBuilder
    implements Builder<GCreateIssueInput, GCreateIssueInputBuilder> {
  _$GCreateIssueInput? _$v;

  ListBuilder<String>? _assigneeIds;
  ListBuilder<String> get assigneeIds =>
      _$this._assigneeIds ??= new ListBuilder<String>();
  set assigneeIds(ListBuilder<String>? assigneeIds) =>
      _$this._assigneeIds = assigneeIds;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _issueTemplate;
  String? get issueTemplate => _$this._issueTemplate;
  set issueTemplate(String? issueTemplate) =>
      _$this._issueTemplate = issueTemplate;

  ListBuilder<String>? _labelIds;
  ListBuilder<String> get labelIds =>
      _$this._labelIds ??= new ListBuilder<String>();
  set labelIds(ListBuilder<String>? labelIds) => _$this._labelIds = labelIds;

  String? _milestoneId;
  String? get milestoneId => _$this._milestoneId;
  set milestoneId(String? milestoneId) => _$this._milestoneId = milestoneId;

  ListBuilder<String>? _projectIds;
  ListBuilder<String> get projectIds =>
      _$this._projectIds ??= new ListBuilder<String>();
  set projectIds(ListBuilder<String>? projectIds) =>
      _$this._projectIds = projectIds;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GCreateIssueInputBuilder();

  GCreateIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _assigneeIds = $v.assigneeIds?.toBuilder();
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _issueTemplate = $v.issueTemplate;
      _labelIds = $v.labelIds?.toBuilder();
      _milestoneId = $v.milestoneId;
      _projectIds = $v.projectIds?.toBuilder();
      _repositoryId = $v.repositoryId;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateIssueInput;
  }

  @override
  void update(void Function(GCreateIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateIssueInput build() {
    _$GCreateIssueInput _$result;
    try {
      _$result = _$v ??
          new _$GCreateIssueInput._(
              assigneeIds: _assigneeIds?.build(),
              body: body,
              clientMutationId: clientMutationId,
              issueTemplate: issueTemplate,
              labelIds: _labelIds?.build(),
              milestoneId: milestoneId,
              projectIds: _projectIds?.build(),
              repositoryId: BuiltValueNullFieldError.checkNotNull(
                  repositoryId, 'GCreateIssueInput', 'repositoryId'),
              title: BuiltValueNullFieldError.checkNotNull(
                  title, 'GCreateIssueInput', 'title'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'assigneeIds';
        _assigneeIds?.build();

        _$failedField = 'labelIds';
        _labelIds?.build();

        _$failedField = 'projectIds';
        _projectIds?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCreateIssueInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCreateProjectInput extends GCreateProjectInput {
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final String name;
  @override
  final String ownerId;
  @override
  final BuiltList<String>? repositoryIds;
  @override
  final GProjectTemplate? template;

  factory _$GCreateProjectInput(
          [void Function(GCreateProjectInputBuilder)? updates]) =>
      (new GCreateProjectInputBuilder()..update(updates)).build();

  _$GCreateProjectInput._(
      {this.body,
      this.clientMutationId,
      required this.name,
      required this.ownerId,
      this.repositoryIds,
      this.template})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(name, 'GCreateProjectInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        ownerId, 'GCreateProjectInput', 'ownerId');
  }

  @override
  GCreateProjectInput rebuild(
          void Function(GCreateProjectInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateProjectInputBuilder toBuilder() =>
      new GCreateProjectInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateProjectInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        ownerId == other.ownerId &&
        repositoryIds == other.repositoryIds &&
        template == other.template;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
                    name.hashCode),
                ownerId.hashCode),
            repositoryIds.hashCode),
        template.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateProjectInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('ownerId', ownerId)
          ..add('repositoryIds', repositoryIds)
          ..add('template', template))
        .toString();
  }
}

class GCreateProjectInputBuilder
    implements Builder<GCreateProjectInput, GCreateProjectInputBuilder> {
  _$GCreateProjectInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _ownerId;
  String? get ownerId => _$this._ownerId;
  set ownerId(String? ownerId) => _$this._ownerId = ownerId;

  ListBuilder<String>? _repositoryIds;
  ListBuilder<String> get repositoryIds =>
      _$this._repositoryIds ??= new ListBuilder<String>();
  set repositoryIds(ListBuilder<String>? repositoryIds) =>
      _$this._repositoryIds = repositoryIds;

  GProjectTemplate? _template;
  GProjectTemplate? get template => _$this._template;
  set template(GProjectTemplate? template) => _$this._template = template;

  GCreateProjectInputBuilder();

  GCreateProjectInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _ownerId = $v.ownerId;
      _repositoryIds = $v.repositoryIds?.toBuilder();
      _template = $v.template;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateProjectInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateProjectInput;
  }

  @override
  void update(void Function(GCreateProjectInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateProjectInput build() {
    _$GCreateProjectInput _$result;
    try {
      _$result = _$v ??
          new _$GCreateProjectInput._(
              body: body,
              clientMutationId: clientMutationId,
              name: BuiltValueNullFieldError.checkNotNull(
                  name, 'GCreateProjectInput', 'name'),
              ownerId: BuiltValueNullFieldError.checkNotNull(
                  ownerId, 'GCreateProjectInput', 'ownerId'),
              repositoryIds: _repositoryIds?.build(),
              template: template);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'repositoryIds';
        _repositoryIds?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCreateProjectInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GCreatePullRequestInput extends GCreatePullRequestInput {
  @override
  final String baseRefName;
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final bool? draft;
  @override
  final String headRefName;
  @override
  final bool? maintainerCanModify;
  @override
  final String repositoryId;
  @override
  final String title;

  factory _$GCreatePullRequestInput(
          [void Function(GCreatePullRequestInputBuilder)? updates]) =>
      (new GCreatePullRequestInputBuilder()..update(updates)).build();

  _$GCreatePullRequestInput._(
      {required this.baseRefName,
      this.body,
      this.clientMutationId,
      this.draft,
      required this.headRefName,
      this.maintainerCanModify,
      required this.repositoryId,
      required this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        baseRefName, 'GCreatePullRequestInput', 'baseRefName');
    BuiltValueNullFieldError.checkNotNull(
        headRefName, 'GCreatePullRequestInput', 'headRefName');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreatePullRequestInput', 'repositoryId');
    BuiltValueNullFieldError.checkNotNull(
        title, 'GCreatePullRequestInput', 'title');
  }

  @override
  GCreatePullRequestInput rebuild(
          void Function(GCreatePullRequestInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreatePullRequestInputBuilder toBuilder() =>
      new GCreatePullRequestInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreatePullRequestInput &&
        baseRefName == other.baseRefName &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        draft == other.draft &&
        headRefName == other.headRefName &&
        maintainerCanModify == other.maintainerCanModify &&
        repositoryId == other.repositoryId &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc($jc($jc(0, baseRefName.hashCode), body.hashCode),
                            clientMutationId.hashCode),
                        draft.hashCode),
                    headRefName.hashCode),
                maintainerCanModify.hashCode),
            repositoryId.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreatePullRequestInput')
          ..add('baseRefName', baseRefName)
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('draft', draft)
          ..add('headRefName', headRefName)
          ..add('maintainerCanModify', maintainerCanModify)
          ..add('repositoryId', repositoryId)
          ..add('title', title))
        .toString();
  }
}

class GCreatePullRequestInputBuilder
    implements
        Builder<GCreatePullRequestInput, GCreatePullRequestInputBuilder> {
  _$GCreatePullRequestInput? _$v;

  String? _baseRefName;
  String? get baseRefName => _$this._baseRefName;
  set baseRefName(String? baseRefName) => _$this._baseRefName = baseRefName;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _draft;
  bool? get draft => _$this._draft;
  set draft(bool? draft) => _$this._draft = draft;

  String? _headRefName;
  String? get headRefName => _$this._headRefName;
  set headRefName(String? headRefName) => _$this._headRefName = headRefName;

  bool? _maintainerCanModify;
  bool? get maintainerCanModify => _$this._maintainerCanModify;
  set maintainerCanModify(bool? maintainerCanModify) =>
      _$this._maintainerCanModify = maintainerCanModify;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GCreatePullRequestInputBuilder();

  GCreatePullRequestInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _baseRefName = $v.baseRefName;
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _draft = $v.draft;
      _headRefName = $v.headRefName;
      _maintainerCanModify = $v.maintainerCanModify;
      _repositoryId = $v.repositoryId;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreatePullRequestInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreatePullRequestInput;
  }

  @override
  void update(void Function(GCreatePullRequestInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreatePullRequestInput build() {
    final _$result = _$v ??
        new _$GCreatePullRequestInput._(
            baseRefName: BuiltValueNullFieldError.checkNotNull(
                baseRefName, 'GCreatePullRequestInput', 'baseRefName'),
            body: body,
            clientMutationId: clientMutationId,
            draft: draft,
            headRefName: BuiltValueNullFieldError.checkNotNull(
                headRefName, 'GCreatePullRequestInput', 'headRefName'),
            maintainerCanModify: maintainerCanModify,
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GCreatePullRequestInput', 'repositoryId'),
            title: BuiltValueNullFieldError.checkNotNull(
                title, 'GCreatePullRequestInput', 'title'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateRefInput extends GCreateRefInput {
  @override
  final String? clientMutationId;
  @override
  final String name;
  @override
  final String oid;
  @override
  final String repositoryId;

  factory _$GCreateRefInput([void Function(GCreateRefInputBuilder)? updates]) =>
      (new GCreateRefInputBuilder()..update(updates)).build();

  _$GCreateRefInput._(
      {this.clientMutationId,
      required this.name,
      required this.oid,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(name, 'GCreateRefInput', 'name');
    BuiltValueNullFieldError.checkNotNull(oid, 'GCreateRefInput', 'oid');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GCreateRefInput', 'repositoryId');
  }

  @override
  GCreateRefInput rebuild(void Function(GCreateRefInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateRefInputBuilder toBuilder() =>
      new GCreateRefInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateRefInput &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        oid == other.oid &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), name.hashCode),
            oid.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateRefInput')
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('oid', oid)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GCreateRefInputBuilder
    implements Builder<GCreateRefInput, GCreateRefInputBuilder> {
  _$GCreateRefInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _oid;
  String? get oid => _$this._oid;
  set oid(String? oid) => _$this._oid = oid;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GCreateRefInputBuilder();

  GCreateRefInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _oid = $v.oid;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateRefInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateRefInput;
  }

  @override
  void update(void Function(GCreateRefInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateRefInput build() {
    final _$result = _$v ??
        new _$GCreateRefInput._(
            clientMutationId: clientMutationId,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GCreateRefInput', 'name'),
            oid: BuiltValueNullFieldError.checkNotNull(
                oid, 'GCreateRefInput', 'oid'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GCreateRefInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateRepositoryInput extends GCreateRepositoryInput {
  @override
  final String? clientMutationId;
  @override
  final String? description;
  @override
  final bool? hasIssuesEnabled;
  @override
  final bool? hasWikiEnabled;
  @override
  final String? homepageUrl;
  @override
  final String name;
  @override
  final String? ownerId;
  @override
  final String? teamId;
  @override
  final bool? template;
  @override
  final GRepositoryVisibility visibility;

  factory _$GCreateRepositoryInput(
          [void Function(GCreateRepositoryInputBuilder)? updates]) =>
      (new GCreateRepositoryInputBuilder()..update(updates)).build();

  _$GCreateRepositoryInput._(
      {this.clientMutationId,
      this.description,
      this.hasIssuesEnabled,
      this.hasWikiEnabled,
      this.homepageUrl,
      required this.name,
      this.ownerId,
      this.teamId,
      this.template,
      required this.visibility})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        name, 'GCreateRepositoryInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        visibility, 'GCreateRepositoryInput', 'visibility');
  }

  @override
  GCreateRepositoryInput rebuild(
          void Function(GCreateRepositoryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateRepositoryInputBuilder toBuilder() =>
      new GCreateRepositoryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateRepositoryInput &&
        clientMutationId == other.clientMutationId &&
        description == other.description &&
        hasIssuesEnabled == other.hasIssuesEnabled &&
        hasWikiEnabled == other.hasWikiEnabled &&
        homepageUrl == other.homepageUrl &&
        name == other.name &&
        ownerId == other.ownerId &&
        teamId == other.teamId &&
        template == other.template &&
        visibility == other.visibility;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc(
                                    $jc($jc(0, clientMutationId.hashCode),
                                        description.hashCode),
                                    hasIssuesEnabled.hashCode),
                                hasWikiEnabled.hashCode),
                            homepageUrl.hashCode),
                        name.hashCode),
                    ownerId.hashCode),
                teamId.hashCode),
            template.hashCode),
        visibility.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateRepositoryInput')
          ..add('clientMutationId', clientMutationId)
          ..add('description', description)
          ..add('hasIssuesEnabled', hasIssuesEnabled)
          ..add('hasWikiEnabled', hasWikiEnabled)
          ..add('homepageUrl', homepageUrl)
          ..add('name', name)
          ..add('ownerId', ownerId)
          ..add('teamId', teamId)
          ..add('template', template)
          ..add('visibility', visibility))
        .toString();
  }
}

class GCreateRepositoryInputBuilder
    implements Builder<GCreateRepositoryInput, GCreateRepositoryInputBuilder> {
  _$GCreateRepositoryInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _description;
  String? get description => _$this._description;
  set description(String? description) => _$this._description = description;

  bool? _hasIssuesEnabled;
  bool? get hasIssuesEnabled => _$this._hasIssuesEnabled;
  set hasIssuesEnabled(bool? hasIssuesEnabled) =>
      _$this._hasIssuesEnabled = hasIssuesEnabled;

  bool? _hasWikiEnabled;
  bool? get hasWikiEnabled => _$this._hasWikiEnabled;
  set hasWikiEnabled(bool? hasWikiEnabled) =>
      _$this._hasWikiEnabled = hasWikiEnabled;

  String? _homepageUrl;
  String? get homepageUrl => _$this._homepageUrl;
  set homepageUrl(String? homepageUrl) => _$this._homepageUrl = homepageUrl;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _ownerId;
  String? get ownerId => _$this._ownerId;
  set ownerId(String? ownerId) => _$this._ownerId = ownerId;

  String? _teamId;
  String? get teamId => _$this._teamId;
  set teamId(String? teamId) => _$this._teamId = teamId;

  bool? _template;
  bool? get template => _$this._template;
  set template(bool? template) => _$this._template = template;

  GRepositoryVisibility? _visibility;
  GRepositoryVisibility? get visibility => _$this._visibility;
  set visibility(GRepositoryVisibility? visibility) =>
      _$this._visibility = visibility;

  GCreateRepositoryInputBuilder();

  GCreateRepositoryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _description = $v.description;
      _hasIssuesEnabled = $v.hasIssuesEnabled;
      _hasWikiEnabled = $v.hasWikiEnabled;
      _homepageUrl = $v.homepageUrl;
      _name = $v.name;
      _ownerId = $v.ownerId;
      _teamId = $v.teamId;
      _template = $v.template;
      _visibility = $v.visibility;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateRepositoryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateRepositoryInput;
  }

  @override
  void update(void Function(GCreateRepositoryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateRepositoryInput build() {
    final _$result = _$v ??
        new _$GCreateRepositoryInput._(
            clientMutationId: clientMutationId,
            description: description,
            hasIssuesEnabled: hasIssuesEnabled,
            hasWikiEnabled: hasWikiEnabled,
            homepageUrl: homepageUrl,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GCreateRepositoryInput', 'name'),
            ownerId: ownerId,
            teamId: teamId,
            template: template,
            visibility: BuiltValueNullFieldError.checkNotNull(
                visibility, 'GCreateRepositoryInput', 'visibility'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateTeamDiscussionCommentInput
    extends GCreateTeamDiscussionCommentInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String discussionId;

  factory _$GCreateTeamDiscussionCommentInput(
          [void Function(GCreateTeamDiscussionCommentInputBuilder)? updates]) =>
      (new GCreateTeamDiscussionCommentInputBuilder()..update(updates)).build();

  _$GCreateTeamDiscussionCommentInput._(
      {required this.body, this.clientMutationId, required this.discussionId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GCreateTeamDiscussionCommentInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        discussionId, 'GCreateTeamDiscussionCommentInput', 'discussionId');
  }

  @override
  GCreateTeamDiscussionCommentInput rebuild(
          void Function(GCreateTeamDiscussionCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateTeamDiscussionCommentInputBuilder toBuilder() =>
      new GCreateTeamDiscussionCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateTeamDiscussionCommentInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        discussionId == other.discussionId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
        discussionId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateTeamDiscussionCommentInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('discussionId', discussionId))
        .toString();
  }
}

class GCreateTeamDiscussionCommentInputBuilder
    implements
        Builder<GCreateTeamDiscussionCommentInput,
            GCreateTeamDiscussionCommentInputBuilder> {
  _$GCreateTeamDiscussionCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _discussionId;
  String? get discussionId => _$this._discussionId;
  set discussionId(String? discussionId) => _$this._discussionId = discussionId;

  GCreateTeamDiscussionCommentInputBuilder();

  GCreateTeamDiscussionCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _discussionId = $v.discussionId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateTeamDiscussionCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateTeamDiscussionCommentInput;
  }

  @override
  void update(
      void Function(GCreateTeamDiscussionCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateTeamDiscussionCommentInput build() {
    final _$result = _$v ??
        new _$GCreateTeamDiscussionCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GCreateTeamDiscussionCommentInput', 'body'),
            clientMutationId: clientMutationId,
            discussionId: BuiltValueNullFieldError.checkNotNull(discussionId,
                'GCreateTeamDiscussionCommentInput', 'discussionId'));
    replace(_$result);
    return _$result;
  }
}

class _$GCreateTeamDiscussionInput extends GCreateTeamDiscussionInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final bool? private;
  @override
  final String teamId;
  @override
  final String title;

  factory _$GCreateTeamDiscussionInput(
          [void Function(GCreateTeamDiscussionInputBuilder)? updates]) =>
      (new GCreateTeamDiscussionInputBuilder()..update(updates)).build();

  _$GCreateTeamDiscussionInput._(
      {required this.body,
      this.clientMutationId,
      this.private,
      required this.teamId,
      required this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GCreateTeamDiscussionInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        teamId, 'GCreateTeamDiscussionInput', 'teamId');
    BuiltValueNullFieldError.checkNotNull(
        title, 'GCreateTeamDiscussionInput', 'title');
  }

  @override
  GCreateTeamDiscussionInput rebuild(
          void Function(GCreateTeamDiscussionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GCreateTeamDiscussionInputBuilder toBuilder() =>
      new GCreateTeamDiscussionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GCreateTeamDiscussionInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        private == other.private &&
        teamId == other.teamId &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
                private.hashCode),
            teamId.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GCreateTeamDiscussionInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('private', private)
          ..add('teamId', teamId)
          ..add('title', title))
        .toString();
  }
}

class GCreateTeamDiscussionInputBuilder
    implements
        Builder<GCreateTeamDiscussionInput, GCreateTeamDiscussionInputBuilder> {
  _$GCreateTeamDiscussionInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _private;
  bool? get private => _$this._private;
  set private(bool? private) => _$this._private = private;

  String? _teamId;
  String? get teamId => _$this._teamId;
  set teamId(String? teamId) => _$this._teamId = teamId;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GCreateTeamDiscussionInputBuilder();

  GCreateTeamDiscussionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _private = $v.private;
      _teamId = $v.teamId;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateTeamDiscussionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GCreateTeamDiscussionInput;
  }

  @override
  void update(void Function(GCreateTeamDiscussionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GCreateTeamDiscussionInput build() {
    final _$result = _$v ??
        new _$GCreateTeamDiscussionInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GCreateTeamDiscussionInput', 'body'),
            clientMutationId: clientMutationId,
            private: private,
            teamId: BuiltValueNullFieldError.checkNotNull(
                teamId, 'GCreateTeamDiscussionInput', 'teamId'),
            title: BuiltValueNullFieldError.checkNotNull(
                title, 'GCreateTeamDiscussionInput', 'title'));
    replace(_$result);
    return _$result;
  }
}

class _$GDate extends GDate {
  @override
  final String value;

  factory _$GDate([void Function(GDateBuilder)? updates]) =>
      (new GDateBuilder()..update(updates)).build();

  _$GDate._({required this.value}) : super._() {
    BuiltValueNullFieldError.checkNotNull(value, 'GDate', 'value');
  }

  @override
  GDate rebuild(void Function(GDateBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDateBuilder toBuilder() => new GDateBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDate && value == other.value;
  }

  @override
  int get hashCode {
    return $jf($jc(0, value.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDate')..add('value', value))
        .toString();
  }
}

class GDateBuilder implements Builder<GDate, GDateBuilder> {
  _$GDate? _$v;

  String? _value;
  String? get value => _$this._value;
  set value(String? value) => _$this._value = value;

  GDateBuilder();

  GDateBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDate other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDate;
  }

  @override
  void update(void Function(GDateBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDate build() {
    final _$result = _$v ??
        new _$GDate._(
            value:
                BuiltValueNullFieldError.checkNotNull(value, 'GDate', 'value'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeclineTopicSuggestionInput extends GDeclineTopicSuggestionInput {
  @override
  final String? clientMutationId;
  @override
  final String name;
  @override
  final GTopicSuggestionDeclineReason reason;
  @override
  final String repositoryId;

  factory _$GDeclineTopicSuggestionInput(
          [void Function(GDeclineTopicSuggestionInputBuilder)? updates]) =>
      (new GDeclineTopicSuggestionInputBuilder()..update(updates)).build();

  _$GDeclineTopicSuggestionInput._(
      {this.clientMutationId,
      required this.name,
      required this.reason,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        name, 'GDeclineTopicSuggestionInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        reason, 'GDeclineTopicSuggestionInput', 'reason');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GDeclineTopicSuggestionInput', 'repositoryId');
  }

  @override
  GDeclineTopicSuggestionInput rebuild(
          void Function(GDeclineTopicSuggestionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeclineTopicSuggestionInputBuilder toBuilder() =>
      new GDeclineTopicSuggestionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeclineTopicSuggestionInput &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        reason == other.reason &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), name.hashCode),
            reason.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeclineTopicSuggestionInput')
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('reason', reason)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GDeclineTopicSuggestionInputBuilder
    implements
        Builder<GDeclineTopicSuggestionInput,
            GDeclineTopicSuggestionInputBuilder> {
  _$GDeclineTopicSuggestionInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  GTopicSuggestionDeclineReason? _reason;
  GTopicSuggestionDeclineReason? get reason => _$this._reason;
  set reason(GTopicSuggestionDeclineReason? reason) => _$this._reason = reason;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GDeclineTopicSuggestionInputBuilder();

  GDeclineTopicSuggestionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _reason = $v.reason;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeclineTopicSuggestionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeclineTopicSuggestionInput;
  }

  @override
  void update(void Function(GDeclineTopicSuggestionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeclineTopicSuggestionInput build() {
    final _$result = _$v ??
        new _$GDeclineTopicSuggestionInput._(
            clientMutationId: clientMutationId,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GDeclineTopicSuggestionInput', 'name'),
            reason: BuiltValueNullFieldError.checkNotNull(
                reason, 'GDeclineTopicSuggestionInput', 'reason'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GDeclineTopicSuggestionInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteBranchProtectionRuleInput
    extends GDeleteBranchProtectionRuleInput {
  @override
  final String branchProtectionRuleId;
  @override
  final String? clientMutationId;

  factory _$GDeleteBranchProtectionRuleInput(
          [void Function(GDeleteBranchProtectionRuleInputBuilder)? updates]) =>
      (new GDeleteBranchProtectionRuleInputBuilder()..update(updates)).build();

  _$GDeleteBranchProtectionRuleInput._(
      {required this.branchProtectionRuleId, this.clientMutationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(branchProtectionRuleId,
        'GDeleteBranchProtectionRuleInput', 'branchProtectionRuleId');
  }

  @override
  GDeleteBranchProtectionRuleInput rebuild(
          void Function(GDeleteBranchProtectionRuleInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteBranchProtectionRuleInputBuilder toBuilder() =>
      new GDeleteBranchProtectionRuleInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteBranchProtectionRuleInput &&
        branchProtectionRuleId == other.branchProtectionRuleId &&
        clientMutationId == other.clientMutationId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(0, branchProtectionRuleId.hashCode), clientMutationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteBranchProtectionRuleInput')
          ..add('branchProtectionRuleId', branchProtectionRuleId)
          ..add('clientMutationId', clientMutationId))
        .toString();
  }
}

class GDeleteBranchProtectionRuleInputBuilder
    implements
        Builder<GDeleteBranchProtectionRuleInput,
            GDeleteBranchProtectionRuleInputBuilder> {
  _$GDeleteBranchProtectionRuleInput? _$v;

  String? _branchProtectionRuleId;
  String? get branchProtectionRuleId => _$this._branchProtectionRuleId;
  set branchProtectionRuleId(String? branchProtectionRuleId) =>
      _$this._branchProtectionRuleId = branchProtectionRuleId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GDeleteBranchProtectionRuleInputBuilder();

  GDeleteBranchProtectionRuleInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _branchProtectionRuleId = $v.branchProtectionRuleId;
      _clientMutationId = $v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteBranchProtectionRuleInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteBranchProtectionRuleInput;
  }

  @override
  void update(void Function(GDeleteBranchProtectionRuleInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteBranchProtectionRuleInput build() {
    final _$result = _$v ??
        new _$GDeleteBranchProtectionRuleInput._(
            branchProtectionRuleId: BuiltValueNullFieldError.checkNotNull(
                branchProtectionRuleId,
                'GDeleteBranchProtectionRuleInput',
                'branchProtectionRuleId'),
            clientMutationId: clientMutationId);
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteDeploymentInput extends GDeleteDeploymentInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteDeploymentInput(
          [void Function(GDeleteDeploymentInputBuilder)? updates]) =>
      (new GDeleteDeploymentInputBuilder()..update(updates)).build();

  _$GDeleteDeploymentInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(id, 'GDeleteDeploymentInput', 'id');
  }

  @override
  GDeleteDeploymentInput rebuild(
          void Function(GDeleteDeploymentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteDeploymentInputBuilder toBuilder() =>
      new GDeleteDeploymentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteDeploymentInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteDeploymentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteDeploymentInputBuilder
    implements Builder<GDeleteDeploymentInput, GDeleteDeploymentInputBuilder> {
  _$GDeleteDeploymentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteDeploymentInputBuilder();

  GDeleteDeploymentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteDeploymentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteDeploymentInput;
  }

  @override
  void update(void Function(GDeleteDeploymentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteDeploymentInput build() {
    final _$result = _$v ??
        new _$GDeleteDeploymentInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteDeploymentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteDiscussionCommentInput extends GDeleteDiscussionCommentInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteDiscussionCommentInput(
          [void Function(GDeleteDiscussionCommentInputBuilder)? updates]) =>
      (new GDeleteDiscussionCommentInputBuilder()..update(updates)).build();

  _$GDeleteDiscussionCommentInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GDeleteDiscussionCommentInput', 'id');
  }

  @override
  GDeleteDiscussionCommentInput rebuild(
          void Function(GDeleteDiscussionCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteDiscussionCommentInputBuilder toBuilder() =>
      new GDeleteDiscussionCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteDiscussionCommentInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteDiscussionCommentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteDiscussionCommentInputBuilder
    implements
        Builder<GDeleteDiscussionCommentInput,
            GDeleteDiscussionCommentInputBuilder> {
  _$GDeleteDiscussionCommentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteDiscussionCommentInputBuilder();

  GDeleteDiscussionCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteDiscussionCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteDiscussionCommentInput;
  }

  @override
  void update(void Function(GDeleteDiscussionCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteDiscussionCommentInput build() {
    final _$result = _$v ??
        new _$GDeleteDiscussionCommentInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteDiscussionCommentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteDiscussionInput extends GDeleteDiscussionInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteDiscussionInput(
          [void Function(GDeleteDiscussionInputBuilder)? updates]) =>
      (new GDeleteDiscussionInputBuilder()..update(updates)).build();

  _$GDeleteDiscussionInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(id, 'GDeleteDiscussionInput', 'id');
  }

  @override
  GDeleteDiscussionInput rebuild(
          void Function(GDeleteDiscussionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteDiscussionInputBuilder toBuilder() =>
      new GDeleteDiscussionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteDiscussionInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteDiscussionInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteDiscussionInputBuilder
    implements Builder<GDeleteDiscussionInput, GDeleteDiscussionInputBuilder> {
  _$GDeleteDiscussionInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteDiscussionInputBuilder();

  GDeleteDiscussionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteDiscussionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteDiscussionInput;
  }

  @override
  void update(void Function(GDeleteDiscussionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteDiscussionInput build() {
    final _$result = _$v ??
        new _$GDeleteDiscussionInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteDiscussionInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteEnvironmentInput extends GDeleteEnvironmentInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteEnvironmentInput(
          [void Function(GDeleteEnvironmentInputBuilder)? updates]) =>
      (new GDeleteEnvironmentInputBuilder()..update(updates)).build();

  _$GDeleteEnvironmentInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(id, 'GDeleteEnvironmentInput', 'id');
  }

  @override
  GDeleteEnvironmentInput rebuild(
          void Function(GDeleteEnvironmentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteEnvironmentInputBuilder toBuilder() =>
      new GDeleteEnvironmentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteEnvironmentInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteEnvironmentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteEnvironmentInputBuilder
    implements
        Builder<GDeleteEnvironmentInput, GDeleteEnvironmentInputBuilder> {
  _$GDeleteEnvironmentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteEnvironmentInputBuilder();

  GDeleteEnvironmentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteEnvironmentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteEnvironmentInput;
  }

  @override
  void update(void Function(GDeleteEnvironmentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteEnvironmentInput build() {
    final _$result = _$v ??
        new _$GDeleteEnvironmentInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteEnvironmentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteIpAllowListEntryInput extends GDeleteIpAllowListEntryInput {
  @override
  final String? clientMutationId;
  @override
  final String ipAllowListEntryId;

  factory _$GDeleteIpAllowListEntryInput(
          [void Function(GDeleteIpAllowListEntryInputBuilder)? updates]) =>
      (new GDeleteIpAllowListEntryInputBuilder()..update(updates)).build();

  _$GDeleteIpAllowListEntryInput._(
      {this.clientMutationId, required this.ipAllowListEntryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(ipAllowListEntryId,
        'GDeleteIpAllowListEntryInput', 'ipAllowListEntryId');
  }

  @override
  GDeleteIpAllowListEntryInput rebuild(
          void Function(GDeleteIpAllowListEntryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteIpAllowListEntryInputBuilder toBuilder() =>
      new GDeleteIpAllowListEntryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteIpAllowListEntryInput &&
        clientMutationId == other.clientMutationId &&
        ipAllowListEntryId == other.ipAllowListEntryId;
  }

  @override
  int get hashCode {
    return $jf(
        $jc($jc(0, clientMutationId.hashCode), ipAllowListEntryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteIpAllowListEntryInput')
          ..add('clientMutationId', clientMutationId)
          ..add('ipAllowListEntryId', ipAllowListEntryId))
        .toString();
  }
}

class GDeleteIpAllowListEntryInputBuilder
    implements
        Builder<GDeleteIpAllowListEntryInput,
            GDeleteIpAllowListEntryInputBuilder> {
  _$GDeleteIpAllowListEntryInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _ipAllowListEntryId;
  String? get ipAllowListEntryId => _$this._ipAllowListEntryId;
  set ipAllowListEntryId(String? ipAllowListEntryId) =>
      _$this._ipAllowListEntryId = ipAllowListEntryId;

  GDeleteIpAllowListEntryInputBuilder();

  GDeleteIpAllowListEntryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _ipAllowListEntryId = $v.ipAllowListEntryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteIpAllowListEntryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteIpAllowListEntryInput;
  }

  @override
  void update(void Function(GDeleteIpAllowListEntryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteIpAllowListEntryInput build() {
    final _$result = _$v ??
        new _$GDeleteIpAllowListEntryInput._(
            clientMutationId: clientMutationId,
            ipAllowListEntryId: BuiltValueNullFieldError.checkNotNull(
                ipAllowListEntryId,
                'GDeleteIpAllowListEntryInput',
                'ipAllowListEntryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteIssueCommentInput extends GDeleteIssueCommentInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteIssueCommentInput(
          [void Function(GDeleteIssueCommentInputBuilder)? updates]) =>
      (new GDeleteIssueCommentInputBuilder()..update(updates)).build();

  _$GDeleteIssueCommentInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(id, 'GDeleteIssueCommentInput', 'id');
  }

  @override
  GDeleteIssueCommentInput rebuild(
          void Function(GDeleteIssueCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteIssueCommentInputBuilder toBuilder() =>
      new GDeleteIssueCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteIssueCommentInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteIssueCommentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteIssueCommentInputBuilder
    implements
        Builder<GDeleteIssueCommentInput, GDeleteIssueCommentInputBuilder> {
  _$GDeleteIssueCommentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteIssueCommentInputBuilder();

  GDeleteIssueCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteIssueCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteIssueCommentInput;
  }

  @override
  void update(void Function(GDeleteIssueCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteIssueCommentInput build() {
    final _$result = _$v ??
        new _$GDeleteIssueCommentInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteIssueCommentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteIssueInput extends GDeleteIssueInput {
  @override
  final String? clientMutationId;
  @override
  final String issueId;

  factory _$GDeleteIssueInput(
          [void Function(GDeleteIssueInputBuilder)? updates]) =>
      (new GDeleteIssueInputBuilder()..update(updates)).build();

  _$GDeleteIssueInput._({this.clientMutationId, required this.issueId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        issueId, 'GDeleteIssueInput', 'issueId');
  }

  @override
  GDeleteIssueInput rebuild(void Function(GDeleteIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteIssueInputBuilder toBuilder() =>
      new GDeleteIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteIssueInput &&
        clientMutationId == other.clientMutationId &&
        issueId == other.issueId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), issueId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteIssueInput')
          ..add('clientMutationId', clientMutationId)
          ..add('issueId', issueId))
        .toString();
  }
}

class GDeleteIssueInputBuilder
    implements Builder<GDeleteIssueInput, GDeleteIssueInputBuilder> {
  _$GDeleteIssueInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _issueId;
  String? get issueId => _$this._issueId;
  set issueId(String? issueId) => _$this._issueId = issueId;

  GDeleteIssueInputBuilder();

  GDeleteIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _issueId = $v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteIssueInput;
  }

  @override
  void update(void Function(GDeleteIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteIssueInput build() {
    final _$result = _$v ??
        new _$GDeleteIssueInput._(
            clientMutationId: clientMutationId,
            issueId: BuiltValueNullFieldError.checkNotNull(
                issueId, 'GDeleteIssueInput', 'issueId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteProjectCardInput extends GDeleteProjectCardInput {
  @override
  final String cardId;
  @override
  final String? clientMutationId;

  factory _$GDeleteProjectCardInput(
          [void Function(GDeleteProjectCardInputBuilder)? updates]) =>
      (new GDeleteProjectCardInputBuilder()..update(updates)).build();

  _$GDeleteProjectCardInput._({required this.cardId, this.clientMutationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        cardId, 'GDeleteProjectCardInput', 'cardId');
  }

  @override
  GDeleteProjectCardInput rebuild(
          void Function(GDeleteProjectCardInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteProjectCardInputBuilder toBuilder() =>
      new GDeleteProjectCardInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteProjectCardInput &&
        cardId == other.cardId &&
        clientMutationId == other.clientMutationId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, cardId.hashCode), clientMutationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteProjectCardInput')
          ..add('cardId', cardId)
          ..add('clientMutationId', clientMutationId))
        .toString();
  }
}

class GDeleteProjectCardInputBuilder
    implements
        Builder<GDeleteProjectCardInput, GDeleteProjectCardInputBuilder> {
  _$GDeleteProjectCardInput? _$v;

  String? _cardId;
  String? get cardId => _$this._cardId;
  set cardId(String? cardId) => _$this._cardId = cardId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GDeleteProjectCardInputBuilder();

  GDeleteProjectCardInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _cardId = $v.cardId;
      _clientMutationId = $v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteProjectCardInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteProjectCardInput;
  }

  @override
  void update(void Function(GDeleteProjectCardInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteProjectCardInput build() {
    final _$result = _$v ??
        new _$GDeleteProjectCardInput._(
            cardId: BuiltValueNullFieldError.checkNotNull(
                cardId, 'GDeleteProjectCardInput', 'cardId'),
            clientMutationId: clientMutationId);
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteProjectColumnInput extends GDeleteProjectColumnInput {
  @override
  final String? clientMutationId;
  @override
  final String columnId;

  factory _$GDeleteProjectColumnInput(
          [void Function(GDeleteProjectColumnInputBuilder)? updates]) =>
      (new GDeleteProjectColumnInputBuilder()..update(updates)).build();

  _$GDeleteProjectColumnInput._({this.clientMutationId, required this.columnId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        columnId, 'GDeleteProjectColumnInput', 'columnId');
  }

  @override
  GDeleteProjectColumnInput rebuild(
          void Function(GDeleteProjectColumnInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteProjectColumnInputBuilder toBuilder() =>
      new GDeleteProjectColumnInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteProjectColumnInput &&
        clientMutationId == other.clientMutationId &&
        columnId == other.columnId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), columnId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteProjectColumnInput')
          ..add('clientMutationId', clientMutationId)
          ..add('columnId', columnId))
        .toString();
  }
}

class GDeleteProjectColumnInputBuilder
    implements
        Builder<GDeleteProjectColumnInput, GDeleteProjectColumnInputBuilder> {
  _$GDeleteProjectColumnInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _columnId;
  String? get columnId => _$this._columnId;
  set columnId(String? columnId) => _$this._columnId = columnId;

  GDeleteProjectColumnInputBuilder();

  GDeleteProjectColumnInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _columnId = $v.columnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteProjectColumnInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteProjectColumnInput;
  }

  @override
  void update(void Function(GDeleteProjectColumnInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteProjectColumnInput build() {
    final _$result = _$v ??
        new _$GDeleteProjectColumnInput._(
            clientMutationId: clientMutationId,
            columnId: BuiltValueNullFieldError.checkNotNull(
                columnId, 'GDeleteProjectColumnInput', 'columnId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteProjectInput extends GDeleteProjectInput {
  @override
  final String? clientMutationId;
  @override
  final String projectId;

  factory _$GDeleteProjectInput(
          [void Function(GDeleteProjectInputBuilder)? updates]) =>
      (new GDeleteProjectInputBuilder()..update(updates)).build();

  _$GDeleteProjectInput._({this.clientMutationId, required this.projectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        projectId, 'GDeleteProjectInput', 'projectId');
  }

  @override
  GDeleteProjectInput rebuild(
          void Function(GDeleteProjectInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteProjectInputBuilder toBuilder() =>
      new GDeleteProjectInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteProjectInput &&
        clientMutationId == other.clientMutationId &&
        projectId == other.projectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), projectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteProjectInput')
          ..add('clientMutationId', clientMutationId)
          ..add('projectId', projectId))
        .toString();
  }
}

class GDeleteProjectInputBuilder
    implements Builder<GDeleteProjectInput, GDeleteProjectInputBuilder> {
  _$GDeleteProjectInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _projectId;
  String? get projectId => _$this._projectId;
  set projectId(String? projectId) => _$this._projectId = projectId;

  GDeleteProjectInputBuilder();

  GDeleteProjectInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _projectId = $v.projectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteProjectInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteProjectInput;
  }

  @override
  void update(void Function(GDeleteProjectInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteProjectInput build() {
    final _$result = _$v ??
        new _$GDeleteProjectInput._(
            clientMutationId: clientMutationId,
            projectId: BuiltValueNullFieldError.checkNotNull(
                projectId, 'GDeleteProjectInput', 'projectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeletePullRequestReviewCommentInput
    extends GDeletePullRequestReviewCommentInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeletePullRequestReviewCommentInput(
          [void Function(GDeletePullRequestReviewCommentInputBuilder)?
              updates]) =>
      (new GDeletePullRequestReviewCommentInputBuilder()..update(updates))
          .build();

  _$GDeletePullRequestReviewCommentInput._(
      {this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GDeletePullRequestReviewCommentInput', 'id');
  }

  @override
  GDeletePullRequestReviewCommentInput rebuild(
          void Function(GDeletePullRequestReviewCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeletePullRequestReviewCommentInputBuilder toBuilder() =>
      new GDeletePullRequestReviewCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeletePullRequestReviewCommentInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeletePullRequestReviewCommentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeletePullRequestReviewCommentInputBuilder
    implements
        Builder<GDeletePullRequestReviewCommentInput,
            GDeletePullRequestReviewCommentInputBuilder> {
  _$GDeletePullRequestReviewCommentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeletePullRequestReviewCommentInputBuilder();

  GDeletePullRequestReviewCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeletePullRequestReviewCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeletePullRequestReviewCommentInput;
  }

  @override
  void update(
      void Function(GDeletePullRequestReviewCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeletePullRequestReviewCommentInput build() {
    final _$result = _$v ??
        new _$GDeletePullRequestReviewCommentInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeletePullRequestReviewCommentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeletePullRequestReviewInput extends GDeletePullRequestReviewInput {
  @override
  final String? clientMutationId;
  @override
  final String pullRequestReviewId;

  factory _$GDeletePullRequestReviewInput(
          [void Function(GDeletePullRequestReviewInputBuilder)? updates]) =>
      (new GDeletePullRequestReviewInputBuilder()..update(updates)).build();

  _$GDeletePullRequestReviewInput._(
      {this.clientMutationId, required this.pullRequestReviewId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(pullRequestReviewId,
        'GDeletePullRequestReviewInput', 'pullRequestReviewId');
  }

  @override
  GDeletePullRequestReviewInput rebuild(
          void Function(GDeletePullRequestReviewInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeletePullRequestReviewInputBuilder toBuilder() =>
      new GDeletePullRequestReviewInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeletePullRequestReviewInput &&
        clientMutationId == other.clientMutationId &&
        pullRequestReviewId == other.pullRequestReviewId;
  }

  @override
  int get hashCode {
    return $jf(
        $jc($jc(0, clientMutationId.hashCode), pullRequestReviewId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeletePullRequestReviewInput')
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestReviewId', pullRequestReviewId))
        .toString();
  }
}

class GDeletePullRequestReviewInputBuilder
    implements
        Builder<GDeletePullRequestReviewInput,
            GDeletePullRequestReviewInputBuilder> {
  _$GDeletePullRequestReviewInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestReviewId;
  String? get pullRequestReviewId => _$this._pullRequestReviewId;
  set pullRequestReviewId(String? pullRequestReviewId) =>
      _$this._pullRequestReviewId = pullRequestReviewId;

  GDeletePullRequestReviewInputBuilder();

  GDeletePullRequestReviewInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _pullRequestReviewId = $v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeletePullRequestReviewInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeletePullRequestReviewInput;
  }

  @override
  void update(void Function(GDeletePullRequestReviewInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeletePullRequestReviewInput build() {
    final _$result = _$v ??
        new _$GDeletePullRequestReviewInput._(
            clientMutationId: clientMutationId,
            pullRequestReviewId: BuiltValueNullFieldError.checkNotNull(
                pullRequestReviewId,
                'GDeletePullRequestReviewInput',
                'pullRequestReviewId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteRefInput extends GDeleteRefInput {
  @override
  final String? clientMutationId;
  @override
  final String refId;

  factory _$GDeleteRefInput([void Function(GDeleteRefInputBuilder)? updates]) =>
      (new GDeleteRefInputBuilder()..update(updates)).build();

  _$GDeleteRefInput._({this.clientMutationId, required this.refId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(refId, 'GDeleteRefInput', 'refId');
  }

  @override
  GDeleteRefInput rebuild(void Function(GDeleteRefInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteRefInputBuilder toBuilder() =>
      new GDeleteRefInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteRefInput &&
        clientMutationId == other.clientMutationId &&
        refId == other.refId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), refId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteRefInput')
          ..add('clientMutationId', clientMutationId)
          ..add('refId', refId))
        .toString();
  }
}

class GDeleteRefInputBuilder
    implements Builder<GDeleteRefInput, GDeleteRefInputBuilder> {
  _$GDeleteRefInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _refId;
  String? get refId => _$this._refId;
  set refId(String? refId) => _$this._refId = refId;

  GDeleteRefInputBuilder();

  GDeleteRefInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _refId = $v.refId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteRefInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteRefInput;
  }

  @override
  void update(void Function(GDeleteRefInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteRefInput build() {
    final _$result = _$v ??
        new _$GDeleteRefInput._(
            clientMutationId: clientMutationId,
            refId: BuiltValueNullFieldError.checkNotNull(
                refId, 'GDeleteRefInput', 'refId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteTeamDiscussionCommentInput
    extends GDeleteTeamDiscussionCommentInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteTeamDiscussionCommentInput(
          [void Function(GDeleteTeamDiscussionCommentInputBuilder)? updates]) =>
      (new GDeleteTeamDiscussionCommentInputBuilder()..update(updates)).build();

  _$GDeleteTeamDiscussionCommentInput._(
      {this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GDeleteTeamDiscussionCommentInput', 'id');
  }

  @override
  GDeleteTeamDiscussionCommentInput rebuild(
          void Function(GDeleteTeamDiscussionCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteTeamDiscussionCommentInputBuilder toBuilder() =>
      new GDeleteTeamDiscussionCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteTeamDiscussionCommentInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteTeamDiscussionCommentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteTeamDiscussionCommentInputBuilder
    implements
        Builder<GDeleteTeamDiscussionCommentInput,
            GDeleteTeamDiscussionCommentInputBuilder> {
  _$GDeleteTeamDiscussionCommentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteTeamDiscussionCommentInputBuilder();

  GDeleteTeamDiscussionCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteTeamDiscussionCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteTeamDiscussionCommentInput;
  }

  @override
  void update(
      void Function(GDeleteTeamDiscussionCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteTeamDiscussionCommentInput build() {
    final _$result = _$v ??
        new _$GDeleteTeamDiscussionCommentInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteTeamDiscussionCommentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteTeamDiscussionInput extends GDeleteTeamDiscussionInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteTeamDiscussionInput(
          [void Function(GDeleteTeamDiscussionInputBuilder)? updates]) =>
      (new GDeleteTeamDiscussionInputBuilder()..update(updates)).build();

  _$GDeleteTeamDiscussionInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GDeleteTeamDiscussionInput', 'id');
  }

  @override
  GDeleteTeamDiscussionInput rebuild(
          void Function(GDeleteTeamDiscussionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteTeamDiscussionInputBuilder toBuilder() =>
      new GDeleteTeamDiscussionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteTeamDiscussionInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteTeamDiscussionInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteTeamDiscussionInputBuilder
    implements
        Builder<GDeleteTeamDiscussionInput, GDeleteTeamDiscussionInputBuilder> {
  _$GDeleteTeamDiscussionInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteTeamDiscussionInputBuilder();

  GDeleteTeamDiscussionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteTeamDiscussionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteTeamDiscussionInput;
  }

  @override
  void update(void Function(GDeleteTeamDiscussionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteTeamDiscussionInput build() {
    final _$result = _$v ??
        new _$GDeleteTeamDiscussionInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteTeamDiscussionInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeleteVerifiableDomainInput extends GDeleteVerifiableDomainInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GDeleteVerifiableDomainInput(
          [void Function(GDeleteVerifiableDomainInputBuilder)? updates]) =>
      (new GDeleteVerifiableDomainInputBuilder()..update(updates)).build();

  _$GDeleteVerifiableDomainInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GDeleteVerifiableDomainInput', 'id');
  }

  @override
  GDeleteVerifiableDomainInput rebuild(
          void Function(GDeleteVerifiableDomainInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeleteVerifiableDomainInputBuilder toBuilder() =>
      new GDeleteVerifiableDomainInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeleteVerifiableDomainInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeleteVerifiableDomainInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GDeleteVerifiableDomainInputBuilder
    implements
        Builder<GDeleteVerifiableDomainInput,
            GDeleteVerifiableDomainInputBuilder> {
  _$GDeleteVerifiableDomainInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GDeleteVerifiableDomainInputBuilder();

  GDeleteVerifiableDomainInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteVerifiableDomainInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeleteVerifiableDomainInput;
  }

  @override
  void update(void Function(GDeleteVerifiableDomainInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeleteVerifiableDomainInput build() {
    final _$result = _$v ??
        new _$GDeleteVerifiableDomainInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GDeleteVerifiableDomainInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GDeploymentOrder extends GDeploymentOrder {
  @override
  final GOrderDirection direction;
  @override
  final GDeploymentOrderField field;

  factory _$GDeploymentOrder(
          [void Function(GDeploymentOrderBuilder)? updates]) =>
      (new GDeploymentOrderBuilder()..update(updates)).build();

  _$GDeploymentOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GDeploymentOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GDeploymentOrder', 'field');
  }

  @override
  GDeploymentOrder rebuild(void Function(GDeploymentOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDeploymentOrderBuilder toBuilder() =>
      new GDeploymentOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDeploymentOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDeploymentOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GDeploymentOrderBuilder
    implements Builder<GDeploymentOrder, GDeploymentOrderBuilder> {
  _$GDeploymentOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GDeploymentOrderField? _field;
  GDeploymentOrderField? get field => _$this._field;
  set field(GDeploymentOrderField? field) => _$this._field = field;

  GDeploymentOrderBuilder();

  GDeploymentOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeploymentOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDeploymentOrder;
  }

  @override
  void update(void Function(GDeploymentOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDeploymentOrder build() {
    final _$result = _$v ??
        new _$GDeploymentOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GDeploymentOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GDeploymentOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GDisablePullRequestAutoMergeInput
    extends GDisablePullRequestAutoMergeInput {
  @override
  final String? clientMutationId;
  @override
  final String pullRequestId;

  factory _$GDisablePullRequestAutoMergeInput(
          [void Function(GDisablePullRequestAutoMergeInputBuilder)? updates]) =>
      (new GDisablePullRequestAutoMergeInputBuilder()..update(updates)).build();

  _$GDisablePullRequestAutoMergeInput._(
      {this.clientMutationId, required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GDisablePullRequestAutoMergeInput', 'pullRequestId');
  }

  @override
  GDisablePullRequestAutoMergeInput rebuild(
          void Function(GDisablePullRequestAutoMergeInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDisablePullRequestAutoMergeInputBuilder toBuilder() =>
      new GDisablePullRequestAutoMergeInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDisablePullRequestAutoMergeInput &&
        clientMutationId == other.clientMutationId &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDisablePullRequestAutoMergeInput')
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GDisablePullRequestAutoMergeInputBuilder
    implements
        Builder<GDisablePullRequestAutoMergeInput,
            GDisablePullRequestAutoMergeInputBuilder> {
  _$GDisablePullRequestAutoMergeInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GDisablePullRequestAutoMergeInputBuilder();

  GDisablePullRequestAutoMergeInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDisablePullRequestAutoMergeInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDisablePullRequestAutoMergeInput;
  }

  @override
  void update(
      void Function(GDisablePullRequestAutoMergeInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDisablePullRequestAutoMergeInput build() {
    final _$result = _$v ??
        new _$GDisablePullRequestAutoMergeInput._(
            clientMutationId: clientMutationId,
            pullRequestId: BuiltValueNullFieldError.checkNotNull(pullRequestId,
                'GDisablePullRequestAutoMergeInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDiscussionOrder extends GDiscussionOrder {
  @override
  final GOrderDirection direction;
  @override
  final GDiscussionOrderField field;

  factory _$GDiscussionOrder(
          [void Function(GDiscussionOrderBuilder)? updates]) =>
      (new GDiscussionOrderBuilder()..update(updates)).build();

  _$GDiscussionOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GDiscussionOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GDiscussionOrder', 'field');
  }

  @override
  GDiscussionOrder rebuild(void Function(GDiscussionOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDiscussionOrderBuilder toBuilder() =>
      new GDiscussionOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDiscussionOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDiscussionOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GDiscussionOrderBuilder
    implements Builder<GDiscussionOrder, GDiscussionOrderBuilder> {
  _$GDiscussionOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GDiscussionOrderField? _field;
  GDiscussionOrderField? get field => _$this._field;
  set field(GDiscussionOrderField? field) => _$this._field = field;

  GDiscussionOrderBuilder();

  GDiscussionOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDiscussionOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDiscussionOrder;
  }

  @override
  void update(void Function(GDiscussionOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDiscussionOrder build() {
    final _$result = _$v ??
        new _$GDiscussionOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GDiscussionOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GDiscussionOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GDismissPullRequestReviewInput extends GDismissPullRequestReviewInput {
  @override
  final String? clientMutationId;
  @override
  final String message;
  @override
  final String pullRequestReviewId;

  factory _$GDismissPullRequestReviewInput(
          [void Function(GDismissPullRequestReviewInputBuilder)? updates]) =>
      (new GDismissPullRequestReviewInputBuilder()..update(updates)).build();

  _$GDismissPullRequestReviewInput._(
      {this.clientMutationId,
      required this.message,
      required this.pullRequestReviewId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        message, 'GDismissPullRequestReviewInput', 'message');
    BuiltValueNullFieldError.checkNotNull(pullRequestReviewId,
        'GDismissPullRequestReviewInput', 'pullRequestReviewId');
  }

  @override
  GDismissPullRequestReviewInput rebuild(
          void Function(GDismissPullRequestReviewInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDismissPullRequestReviewInputBuilder toBuilder() =>
      new GDismissPullRequestReviewInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDismissPullRequestReviewInput &&
        clientMutationId == other.clientMutationId &&
        message == other.message &&
        pullRequestReviewId == other.pullRequestReviewId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), message.hashCode),
        pullRequestReviewId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDismissPullRequestReviewInput')
          ..add('clientMutationId', clientMutationId)
          ..add('message', message)
          ..add('pullRequestReviewId', pullRequestReviewId))
        .toString();
  }
}

class GDismissPullRequestReviewInputBuilder
    implements
        Builder<GDismissPullRequestReviewInput,
            GDismissPullRequestReviewInputBuilder> {
  _$GDismissPullRequestReviewInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _message;
  String? get message => _$this._message;
  set message(String? message) => _$this._message = message;

  String? _pullRequestReviewId;
  String? get pullRequestReviewId => _$this._pullRequestReviewId;
  set pullRequestReviewId(String? pullRequestReviewId) =>
      _$this._pullRequestReviewId = pullRequestReviewId;

  GDismissPullRequestReviewInputBuilder();

  GDismissPullRequestReviewInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _message = $v.message;
      _pullRequestReviewId = $v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDismissPullRequestReviewInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDismissPullRequestReviewInput;
  }

  @override
  void update(void Function(GDismissPullRequestReviewInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDismissPullRequestReviewInput build() {
    final _$result = _$v ??
        new _$GDismissPullRequestReviewInput._(
            clientMutationId: clientMutationId,
            message: BuiltValueNullFieldError.checkNotNull(
                message, 'GDismissPullRequestReviewInput', 'message'),
            pullRequestReviewId: BuiltValueNullFieldError.checkNotNull(
                pullRequestReviewId,
                'GDismissPullRequestReviewInput',
                'pullRequestReviewId'));
    replace(_$result);
    return _$result;
  }
}

class _$GDraftPullRequestReviewComment extends GDraftPullRequestReviewComment {
  @override
  final String body;
  @override
  final String path;
  @override
  final int position;

  factory _$GDraftPullRequestReviewComment(
          [void Function(GDraftPullRequestReviewCommentBuilder)? updates]) =>
      (new GDraftPullRequestReviewCommentBuilder()..update(updates)).build();

  _$GDraftPullRequestReviewComment._(
      {required this.body, required this.path, required this.position})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GDraftPullRequestReviewComment', 'body');
    BuiltValueNullFieldError.checkNotNull(
        path, 'GDraftPullRequestReviewComment', 'path');
    BuiltValueNullFieldError.checkNotNull(
        position, 'GDraftPullRequestReviewComment', 'position');
  }

  @override
  GDraftPullRequestReviewComment rebuild(
          void Function(GDraftPullRequestReviewCommentBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDraftPullRequestReviewCommentBuilder toBuilder() =>
      new GDraftPullRequestReviewCommentBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDraftPullRequestReviewComment &&
        body == other.body &&
        path == other.path &&
        position == other.position;
  }

  @override
  int get hashCode {
    return $jf(
        $jc($jc($jc(0, body.hashCode), path.hashCode), position.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDraftPullRequestReviewComment')
          ..add('body', body)
          ..add('path', path)
          ..add('position', position))
        .toString();
  }
}

class GDraftPullRequestReviewCommentBuilder
    implements
        Builder<GDraftPullRequestReviewComment,
            GDraftPullRequestReviewCommentBuilder> {
  _$GDraftPullRequestReviewComment? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _path;
  String? get path => _$this._path;
  set path(String? path) => _$this._path = path;

  int? _position;
  int? get position => _$this._position;
  set position(int? position) => _$this._position = position;

  GDraftPullRequestReviewCommentBuilder();

  GDraftPullRequestReviewCommentBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _path = $v.path;
      _position = $v.position;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDraftPullRequestReviewComment other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDraftPullRequestReviewComment;
  }

  @override
  void update(void Function(GDraftPullRequestReviewCommentBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDraftPullRequestReviewComment build() {
    final _$result = _$v ??
        new _$GDraftPullRequestReviewComment._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GDraftPullRequestReviewComment', 'body'),
            path: BuiltValueNullFieldError.checkNotNull(
                path, 'GDraftPullRequestReviewComment', 'path'),
            position: BuiltValueNullFieldError.checkNotNull(
                position, 'GDraftPullRequestReviewComment', 'position'));
    replace(_$result);
    return _$result;
  }
}

class _$GDraftPullRequestReviewThread extends GDraftPullRequestReviewThread {
  @override
  final String body;
  @override
  final int line;
  @override
  final String path;
  @override
  final GDiffSide? side;
  @override
  final int? startLine;
  @override
  final GDiffSide? startSide;

  factory _$GDraftPullRequestReviewThread(
          [void Function(GDraftPullRequestReviewThreadBuilder)? updates]) =>
      (new GDraftPullRequestReviewThreadBuilder()..update(updates)).build();

  _$GDraftPullRequestReviewThread._(
      {required this.body,
      required this.line,
      required this.path,
      this.side,
      this.startLine,
      this.startSide})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GDraftPullRequestReviewThread', 'body');
    BuiltValueNullFieldError.checkNotNull(
        line, 'GDraftPullRequestReviewThread', 'line');
    BuiltValueNullFieldError.checkNotNull(
        path, 'GDraftPullRequestReviewThread', 'path');
  }

  @override
  GDraftPullRequestReviewThread rebuild(
          void Function(GDraftPullRequestReviewThreadBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GDraftPullRequestReviewThreadBuilder toBuilder() =>
      new GDraftPullRequestReviewThreadBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GDraftPullRequestReviewThread &&
        body == other.body &&
        line == other.line &&
        path == other.path &&
        side == other.side &&
        startLine == other.startLine &&
        startSide == other.startSide;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc($jc(0, body.hashCode), line.hashCode), path.hashCode),
                side.hashCode),
            startLine.hashCode),
        startSide.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GDraftPullRequestReviewThread')
          ..add('body', body)
          ..add('line', line)
          ..add('path', path)
          ..add('side', side)
          ..add('startLine', startLine)
          ..add('startSide', startSide))
        .toString();
  }
}

class GDraftPullRequestReviewThreadBuilder
    implements
        Builder<GDraftPullRequestReviewThread,
            GDraftPullRequestReviewThreadBuilder> {
  _$GDraftPullRequestReviewThread? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  int? _line;
  int? get line => _$this._line;
  set line(int? line) => _$this._line = line;

  String? _path;
  String? get path => _$this._path;
  set path(String? path) => _$this._path = path;

  GDiffSide? _side;
  GDiffSide? get side => _$this._side;
  set side(GDiffSide? side) => _$this._side = side;

  int? _startLine;
  int? get startLine => _$this._startLine;
  set startLine(int? startLine) => _$this._startLine = startLine;

  GDiffSide? _startSide;
  GDiffSide? get startSide => _$this._startSide;
  set startSide(GDiffSide? startSide) => _$this._startSide = startSide;

  GDraftPullRequestReviewThreadBuilder();

  GDraftPullRequestReviewThreadBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _line = $v.line;
      _path = $v.path;
      _side = $v.side;
      _startLine = $v.startLine;
      _startSide = $v.startSide;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDraftPullRequestReviewThread other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GDraftPullRequestReviewThread;
  }

  @override
  void update(void Function(GDraftPullRequestReviewThreadBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GDraftPullRequestReviewThread build() {
    final _$result = _$v ??
        new _$GDraftPullRequestReviewThread._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GDraftPullRequestReviewThread', 'body'),
            line: BuiltValueNullFieldError.checkNotNull(
                line, 'GDraftPullRequestReviewThread', 'line'),
            path: BuiltValueNullFieldError.checkNotNull(
                path, 'GDraftPullRequestReviewThread', 'path'),
            side: side,
            startLine: startLine,
            startSide: startSide);
    replace(_$result);
    return _$result;
  }
}

class _$GEnablePullRequestAutoMergeInput
    extends GEnablePullRequestAutoMergeInput {
  @override
  final String? authorEmail;
  @override
  final String? clientMutationId;
  @override
  final String? commitBody;
  @override
  final String? commitHeadline;
  @override
  final GPullRequestMergeMethod? mergeMethod;
  @override
  final String pullRequestId;

  factory _$GEnablePullRequestAutoMergeInput(
          [void Function(GEnablePullRequestAutoMergeInputBuilder)? updates]) =>
      (new GEnablePullRequestAutoMergeInputBuilder()..update(updates)).build();

  _$GEnablePullRequestAutoMergeInput._(
      {this.authorEmail,
      this.clientMutationId,
      this.commitBody,
      this.commitHeadline,
      this.mergeMethod,
      required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GEnablePullRequestAutoMergeInput', 'pullRequestId');
  }

  @override
  GEnablePullRequestAutoMergeInput rebuild(
          void Function(GEnablePullRequestAutoMergeInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GEnablePullRequestAutoMergeInputBuilder toBuilder() =>
      new GEnablePullRequestAutoMergeInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GEnablePullRequestAutoMergeInput &&
        authorEmail == other.authorEmail &&
        clientMutationId == other.clientMutationId &&
        commitBody == other.commitBody &&
        commitHeadline == other.commitHeadline &&
        mergeMethod == other.mergeMethod &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc($jc(0, authorEmail.hashCode),
                        clientMutationId.hashCode),
                    commitBody.hashCode),
                commitHeadline.hashCode),
            mergeMethod.hashCode),
        pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GEnablePullRequestAutoMergeInput')
          ..add('authorEmail', authorEmail)
          ..add('clientMutationId', clientMutationId)
          ..add('commitBody', commitBody)
          ..add('commitHeadline', commitHeadline)
          ..add('mergeMethod', mergeMethod)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GEnablePullRequestAutoMergeInputBuilder
    implements
        Builder<GEnablePullRequestAutoMergeInput,
            GEnablePullRequestAutoMergeInputBuilder> {
  _$GEnablePullRequestAutoMergeInput? _$v;

  String? _authorEmail;
  String? get authorEmail => _$this._authorEmail;
  set authorEmail(String? authorEmail) => _$this._authorEmail = authorEmail;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _commitBody;
  String? get commitBody => _$this._commitBody;
  set commitBody(String? commitBody) => _$this._commitBody = commitBody;

  String? _commitHeadline;
  String? get commitHeadline => _$this._commitHeadline;
  set commitHeadline(String? commitHeadline) =>
      _$this._commitHeadline = commitHeadline;

  GPullRequestMergeMethod? _mergeMethod;
  GPullRequestMergeMethod? get mergeMethod => _$this._mergeMethod;
  set mergeMethod(GPullRequestMergeMethod? mergeMethod) =>
      _$this._mergeMethod = mergeMethod;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GEnablePullRequestAutoMergeInputBuilder();

  GEnablePullRequestAutoMergeInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _authorEmail = $v.authorEmail;
      _clientMutationId = $v.clientMutationId;
      _commitBody = $v.commitBody;
      _commitHeadline = $v.commitHeadline;
      _mergeMethod = $v.mergeMethod;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnablePullRequestAutoMergeInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GEnablePullRequestAutoMergeInput;
  }

  @override
  void update(void Function(GEnablePullRequestAutoMergeInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GEnablePullRequestAutoMergeInput build() {
    final _$result = _$v ??
        new _$GEnablePullRequestAutoMergeInput._(
            authorEmail: authorEmail,
            clientMutationId: clientMutationId,
            commitBody: commitBody,
            commitHeadline: commitHeadline,
            mergeMethod: mergeMethod,
            pullRequestId: BuiltValueNullFieldError.checkNotNull(pullRequestId,
                'GEnablePullRequestAutoMergeInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GEnterpriseAdministratorInvitationOrder
    extends GEnterpriseAdministratorInvitationOrder {
  @override
  final GOrderDirection direction;
  @override
  final GEnterpriseAdministratorInvitationOrderField field;

  factory _$GEnterpriseAdministratorInvitationOrder(
          [void Function(GEnterpriseAdministratorInvitationOrderBuilder)?
              updates]) =>
      (new GEnterpriseAdministratorInvitationOrderBuilder()..update(updates))
          .build();

  _$GEnterpriseAdministratorInvitationOrder._(
      {required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GEnterpriseAdministratorInvitationOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GEnterpriseAdministratorInvitationOrder', 'field');
  }

  @override
  GEnterpriseAdministratorInvitationOrder rebuild(
          void Function(GEnterpriseAdministratorInvitationOrderBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GEnterpriseAdministratorInvitationOrderBuilder toBuilder() =>
      new GEnterpriseAdministratorInvitationOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GEnterpriseAdministratorInvitationOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GEnterpriseAdministratorInvitationOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GEnterpriseAdministratorInvitationOrderBuilder
    implements
        Builder<GEnterpriseAdministratorInvitationOrder,
            GEnterpriseAdministratorInvitationOrderBuilder> {
  _$GEnterpriseAdministratorInvitationOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GEnterpriseAdministratorInvitationOrderField? _field;
  GEnterpriseAdministratorInvitationOrderField? get field => _$this._field;
  set field(GEnterpriseAdministratorInvitationOrderField? field) =>
      _$this._field = field;

  GEnterpriseAdministratorInvitationOrderBuilder();

  GEnterpriseAdministratorInvitationOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseAdministratorInvitationOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GEnterpriseAdministratorInvitationOrder;
  }

  @override
  void update(
      void Function(GEnterpriseAdministratorInvitationOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GEnterpriseAdministratorInvitationOrder build() {
    final _$result = _$v ??
        new _$GEnterpriseAdministratorInvitationOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(direction,
                'GEnterpriseAdministratorInvitationOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GEnterpriseAdministratorInvitationOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GEnterpriseMemberOrder extends GEnterpriseMemberOrder {
  @override
  final GOrderDirection direction;
  @override
  final GEnterpriseMemberOrderField field;

  factory _$GEnterpriseMemberOrder(
          [void Function(GEnterpriseMemberOrderBuilder)? updates]) =>
      (new GEnterpriseMemberOrderBuilder()..update(updates)).build();

  _$GEnterpriseMemberOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GEnterpriseMemberOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GEnterpriseMemberOrder', 'field');
  }

  @override
  GEnterpriseMemberOrder rebuild(
          void Function(GEnterpriseMemberOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GEnterpriseMemberOrderBuilder toBuilder() =>
      new GEnterpriseMemberOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GEnterpriseMemberOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GEnterpriseMemberOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GEnterpriseMemberOrderBuilder
    implements Builder<GEnterpriseMemberOrder, GEnterpriseMemberOrderBuilder> {
  _$GEnterpriseMemberOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GEnterpriseMemberOrderField? _field;
  GEnterpriseMemberOrderField? get field => _$this._field;
  set field(GEnterpriseMemberOrderField? field) => _$this._field = field;

  GEnterpriseMemberOrderBuilder();

  GEnterpriseMemberOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseMemberOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GEnterpriseMemberOrder;
  }

  @override
  void update(void Function(GEnterpriseMemberOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GEnterpriseMemberOrder build() {
    final _$result = _$v ??
        new _$GEnterpriseMemberOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GEnterpriseMemberOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GEnterpriseMemberOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GEnterpriseServerInstallationOrder
    extends GEnterpriseServerInstallationOrder {
  @override
  final GOrderDirection direction;
  @override
  final GEnterpriseServerInstallationOrderField field;

  factory _$GEnterpriseServerInstallationOrder(
          [void Function(GEnterpriseServerInstallationOrderBuilder)?
              updates]) =>
      (new GEnterpriseServerInstallationOrderBuilder()..update(updates))
          .build();

  _$GEnterpriseServerInstallationOrder._(
      {required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GEnterpriseServerInstallationOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GEnterpriseServerInstallationOrder', 'field');
  }

  @override
  GEnterpriseServerInstallationOrder rebuild(
          void Function(GEnterpriseServerInstallationOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GEnterpriseServerInstallationOrderBuilder toBuilder() =>
      new GEnterpriseServerInstallationOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GEnterpriseServerInstallationOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GEnterpriseServerInstallationOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GEnterpriseServerInstallationOrderBuilder
    implements
        Builder<GEnterpriseServerInstallationOrder,
            GEnterpriseServerInstallationOrderBuilder> {
  _$GEnterpriseServerInstallationOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GEnterpriseServerInstallationOrderField? _field;
  GEnterpriseServerInstallationOrderField? get field => _$this._field;
  set field(GEnterpriseServerInstallationOrderField? field) =>
      _$this._field = field;

  GEnterpriseServerInstallationOrderBuilder();

  GEnterpriseServerInstallationOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerInstallationOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GEnterpriseServerInstallationOrder;
  }

  @override
  void update(
      void Function(GEnterpriseServerInstallationOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GEnterpriseServerInstallationOrder build() {
    final _$result = _$v ??
        new _$GEnterpriseServerInstallationOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GEnterpriseServerInstallationOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GEnterpriseServerInstallationOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GEnterpriseServerUserAccountEmailOrder
    extends GEnterpriseServerUserAccountEmailOrder {
  @override
  final GOrderDirection direction;
  @override
  final GEnterpriseServerUserAccountEmailOrderField field;

  factory _$GEnterpriseServerUserAccountEmailOrder(
          [void Function(GEnterpriseServerUserAccountEmailOrderBuilder)?
              updates]) =>
      (new GEnterpriseServerUserAccountEmailOrderBuilder()..update(updates))
          .build();

  _$GEnterpriseServerUserAccountEmailOrder._(
      {required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GEnterpriseServerUserAccountEmailOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GEnterpriseServerUserAccountEmailOrder', 'field');
  }

  @override
  GEnterpriseServerUserAccountEmailOrder rebuild(
          void Function(GEnterpriseServerUserAccountEmailOrderBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GEnterpriseServerUserAccountEmailOrderBuilder toBuilder() =>
      new GEnterpriseServerUserAccountEmailOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GEnterpriseServerUserAccountEmailOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GEnterpriseServerUserAccountEmailOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GEnterpriseServerUserAccountEmailOrderBuilder
    implements
        Builder<GEnterpriseServerUserAccountEmailOrder,
            GEnterpriseServerUserAccountEmailOrderBuilder> {
  _$GEnterpriseServerUserAccountEmailOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GEnterpriseServerUserAccountEmailOrderField? _field;
  GEnterpriseServerUserAccountEmailOrderField? get field => _$this._field;
  set field(GEnterpriseServerUserAccountEmailOrderField? field) =>
      _$this._field = field;

  GEnterpriseServerUserAccountEmailOrderBuilder();

  GEnterpriseServerUserAccountEmailOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerUserAccountEmailOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GEnterpriseServerUserAccountEmailOrder;
  }

  @override
  void update(
      void Function(GEnterpriseServerUserAccountEmailOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GEnterpriseServerUserAccountEmailOrder build() {
    final _$result = _$v ??
        new _$GEnterpriseServerUserAccountEmailOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(direction,
                'GEnterpriseServerUserAccountEmailOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GEnterpriseServerUserAccountEmailOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GEnterpriseServerUserAccountOrder
    extends GEnterpriseServerUserAccountOrder {
  @override
  final GOrderDirection direction;
  @override
  final GEnterpriseServerUserAccountOrderField field;

  factory _$GEnterpriseServerUserAccountOrder(
          [void Function(GEnterpriseServerUserAccountOrderBuilder)? updates]) =>
      (new GEnterpriseServerUserAccountOrderBuilder()..update(updates)).build();

  _$GEnterpriseServerUserAccountOrder._(
      {required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GEnterpriseServerUserAccountOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GEnterpriseServerUserAccountOrder', 'field');
  }

  @override
  GEnterpriseServerUserAccountOrder rebuild(
          void Function(GEnterpriseServerUserAccountOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GEnterpriseServerUserAccountOrderBuilder toBuilder() =>
      new GEnterpriseServerUserAccountOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GEnterpriseServerUserAccountOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GEnterpriseServerUserAccountOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GEnterpriseServerUserAccountOrderBuilder
    implements
        Builder<GEnterpriseServerUserAccountOrder,
            GEnterpriseServerUserAccountOrderBuilder> {
  _$GEnterpriseServerUserAccountOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GEnterpriseServerUserAccountOrderField? _field;
  GEnterpriseServerUserAccountOrderField? get field => _$this._field;
  set field(GEnterpriseServerUserAccountOrderField? field) =>
      _$this._field = field;

  GEnterpriseServerUserAccountOrderBuilder();

  GEnterpriseServerUserAccountOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerUserAccountOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GEnterpriseServerUserAccountOrder;
  }

  @override
  void update(
      void Function(GEnterpriseServerUserAccountOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GEnterpriseServerUserAccountOrder build() {
    final _$result = _$v ??
        new _$GEnterpriseServerUserAccountOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GEnterpriseServerUserAccountOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GEnterpriseServerUserAccountOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GEnterpriseServerUserAccountsUploadOrder
    extends GEnterpriseServerUserAccountsUploadOrder {
  @override
  final GOrderDirection direction;
  @override
  final GEnterpriseServerUserAccountsUploadOrderField field;

  factory _$GEnterpriseServerUserAccountsUploadOrder(
          [void Function(GEnterpriseServerUserAccountsUploadOrderBuilder)?
              updates]) =>
      (new GEnterpriseServerUserAccountsUploadOrderBuilder()..update(updates))
          .build();

  _$GEnterpriseServerUserAccountsUploadOrder._(
      {required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GEnterpriseServerUserAccountsUploadOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GEnterpriseServerUserAccountsUploadOrder', 'field');
  }

  @override
  GEnterpriseServerUserAccountsUploadOrder rebuild(
          void Function(GEnterpriseServerUserAccountsUploadOrderBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GEnterpriseServerUserAccountsUploadOrderBuilder toBuilder() =>
      new GEnterpriseServerUserAccountsUploadOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GEnterpriseServerUserAccountsUploadOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GEnterpriseServerUserAccountsUploadOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GEnterpriseServerUserAccountsUploadOrderBuilder
    implements
        Builder<GEnterpriseServerUserAccountsUploadOrder,
            GEnterpriseServerUserAccountsUploadOrderBuilder> {
  _$GEnterpriseServerUserAccountsUploadOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GEnterpriseServerUserAccountsUploadOrderField? _field;
  GEnterpriseServerUserAccountsUploadOrderField? get field => _$this._field;
  set field(GEnterpriseServerUserAccountsUploadOrderField? field) =>
      _$this._field = field;

  GEnterpriseServerUserAccountsUploadOrderBuilder();

  GEnterpriseServerUserAccountsUploadOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerUserAccountsUploadOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GEnterpriseServerUserAccountsUploadOrder;
  }

  @override
  void update(
      void Function(GEnterpriseServerUserAccountsUploadOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GEnterpriseServerUserAccountsUploadOrder build() {
    final _$result = _$v ??
        new _$GEnterpriseServerUserAccountsUploadOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(direction,
                'GEnterpriseServerUserAccountsUploadOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GEnterpriseServerUserAccountsUploadOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GFollowUserInput extends GFollowUserInput {
  @override
  final String? clientMutationId;
  @override
  final String userId;

  factory _$GFollowUserInput(
          [void Function(GFollowUserInputBuilder)? updates]) =>
      (new GFollowUserInputBuilder()..update(updates)).build();

  _$GFollowUserInput._({this.clientMutationId, required this.userId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(userId, 'GFollowUserInput', 'userId');
  }

  @override
  GFollowUserInput rebuild(void Function(GFollowUserInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GFollowUserInputBuilder toBuilder() =>
      new GFollowUserInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GFollowUserInput &&
        clientMutationId == other.clientMutationId &&
        userId == other.userId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), userId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GFollowUserInput')
          ..add('clientMutationId', clientMutationId)
          ..add('userId', userId))
        .toString();
  }
}

class GFollowUserInputBuilder
    implements Builder<GFollowUserInput, GFollowUserInputBuilder> {
  _$GFollowUserInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _userId;
  String? get userId => _$this._userId;
  set userId(String? userId) => _$this._userId = userId;

  GFollowUserInputBuilder();

  GFollowUserInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _userId = $v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GFollowUserInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GFollowUserInput;
  }

  @override
  void update(void Function(GFollowUserInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GFollowUserInput build() {
    final _$result = _$v ??
        new _$GFollowUserInput._(
            clientMutationId: clientMutationId,
            userId: BuiltValueNullFieldError.checkNotNull(
                userId, 'GFollowUserInput', 'userId'));
    replace(_$result);
    return _$result;
  }
}

class _$GGistOrder extends GGistOrder {
  @override
  final GOrderDirection direction;
  @override
  final GGistOrderField field;

  factory _$GGistOrder([void Function(GGistOrderBuilder)? updates]) =>
      (new GGistOrderBuilder()..update(updates)).build();

  _$GGistOrder._({required this.direction, required this.field}) : super._() {
    BuiltValueNullFieldError.checkNotNull(direction, 'GGistOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GGistOrder', 'field');
  }

  @override
  GGistOrder rebuild(void Function(GGistOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GGistOrderBuilder toBuilder() => new GGistOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GGistOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GGistOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GGistOrderBuilder implements Builder<GGistOrder, GGistOrderBuilder> {
  _$GGistOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GGistOrderField? _field;
  GGistOrderField? get field => _$this._field;
  set field(GGistOrderField? field) => _$this._field = field;

  GGistOrderBuilder();

  GGistOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GGistOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GGistOrder;
  }

  @override
  void update(void Function(GGistOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GGistOrder build() {
    final _$result = _$v ??
        new _$GGistOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GGistOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GGistOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GGitSSHRemote extends GGitSSHRemote {
  @override
  final String value;

  factory _$GGitSSHRemote([void Function(GGitSSHRemoteBuilder)? updates]) =>
      (new GGitSSHRemoteBuilder()..update(updates)).build();

  _$GGitSSHRemote._({required this.value}) : super._() {
    BuiltValueNullFieldError.checkNotNull(value, 'GGitSSHRemote', 'value');
  }

  @override
  GGitSSHRemote rebuild(void Function(GGitSSHRemoteBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GGitSSHRemoteBuilder toBuilder() => new GGitSSHRemoteBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GGitSSHRemote && value == other.value;
  }

  @override
  int get hashCode {
    return $jf($jc(0, value.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GGitSSHRemote')..add('value', value))
        .toString();
  }
}

class GGitSSHRemoteBuilder
    implements Builder<GGitSSHRemote, GGitSSHRemoteBuilder> {
  _$GGitSSHRemote? _$v;

  String? _value;
  String? get value => _$this._value;
  set value(String? value) => _$this._value = value;

  GGitSSHRemoteBuilder();

  GGitSSHRemoteBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GGitSSHRemote other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GGitSSHRemote;
  }

  @override
  void update(void Function(GGitSSHRemoteBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GGitSSHRemote build() {
    final _$result = _$v ??
        new _$GGitSSHRemote._(
            value: BuiltValueNullFieldError.checkNotNull(
                value, 'GGitSSHRemote', 'value'));
    replace(_$result);
    return _$result;
  }
}

class _$GGitTimestamp extends GGitTimestamp {
  @override
  final String value;

  factory _$GGitTimestamp([void Function(GGitTimestampBuilder)? updates]) =>
      (new GGitTimestampBuilder()..update(updates)).build();

  _$GGitTimestamp._({required this.value}) : super._() {
    BuiltValueNullFieldError.checkNotNull(value, 'GGitTimestamp', 'value');
  }

  @override
  GGitTimestamp rebuild(void Function(GGitTimestampBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GGitTimestampBuilder toBuilder() => new GGitTimestampBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GGitTimestamp && value == other.value;
  }

  @override
  int get hashCode {
    return $jf($jc(0, value.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GGitTimestamp')..add('value', value))
        .toString();
  }
}

class GGitTimestampBuilder
    implements Builder<GGitTimestamp, GGitTimestampBuilder> {
  _$GGitTimestamp? _$v;

  String? _value;
  String? get value => _$this._value;
  set value(String? value) => _$this._value = value;

  GGitTimestampBuilder();

  GGitTimestampBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GGitTimestamp other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GGitTimestamp;
  }

  @override
  void update(void Function(GGitTimestampBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GGitTimestamp build() {
    final _$result = _$v ??
        new _$GGitTimestamp._(
            value: BuiltValueNullFieldError.checkNotNull(
                value, 'GGitTimestamp', 'value'));
    replace(_$result);
    return _$result;
  }
}

class _$GHTML extends GHTML {
  @override
  final String value;

  factory _$GHTML([void Function(GHTMLBuilder)? updates]) =>
      (new GHTMLBuilder()..update(updates)).build();

  _$GHTML._({required this.value}) : super._() {
    BuiltValueNullFieldError.checkNotNull(value, 'GHTML', 'value');
  }

  @override
  GHTML rebuild(void Function(GHTMLBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GHTMLBuilder toBuilder() => new GHTMLBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GHTML && value == other.value;
  }

  @override
  int get hashCode {
    return $jf($jc(0, value.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GHTML')..add('value', value))
        .toString();
  }
}

class GHTMLBuilder implements Builder<GHTML, GHTMLBuilder> {
  _$GHTML? _$v;

  String? _value;
  String? get value => _$this._value;
  set value(String? value) => _$this._value = value;

  GHTMLBuilder();

  GHTMLBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GHTML other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GHTML;
  }

  @override
  void update(void Function(GHTMLBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GHTML build() {
    final _$result = _$v ??
        new _$GHTML._(
            value:
                BuiltValueNullFieldError.checkNotNull(value, 'GHTML', 'value'));
    replace(_$result);
    return _$result;
  }
}

class _$GInviteEnterpriseAdminInput extends GInviteEnterpriseAdminInput {
  @override
  final String? clientMutationId;
  @override
  final String? email;
  @override
  final String enterpriseId;
  @override
  final String? invitee;
  @override
  final GEnterpriseAdministratorRole? role;

  factory _$GInviteEnterpriseAdminInput(
          [void Function(GInviteEnterpriseAdminInputBuilder)? updates]) =>
      (new GInviteEnterpriseAdminInputBuilder()..update(updates)).build();

  _$GInviteEnterpriseAdminInput._(
      {this.clientMutationId,
      this.email,
      required this.enterpriseId,
      this.invitee,
      this.role})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GInviteEnterpriseAdminInput', 'enterpriseId');
  }

  @override
  GInviteEnterpriseAdminInput rebuild(
          void Function(GInviteEnterpriseAdminInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GInviteEnterpriseAdminInputBuilder toBuilder() =>
      new GInviteEnterpriseAdminInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GInviteEnterpriseAdminInput &&
        clientMutationId == other.clientMutationId &&
        email == other.email &&
        enterpriseId == other.enterpriseId &&
        invitee == other.invitee &&
        role == other.role;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, clientMutationId.hashCode), email.hashCode),
                enterpriseId.hashCode),
            invitee.hashCode),
        role.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GInviteEnterpriseAdminInput')
          ..add('clientMutationId', clientMutationId)
          ..add('email', email)
          ..add('enterpriseId', enterpriseId)
          ..add('invitee', invitee)
          ..add('role', role))
        .toString();
  }
}

class GInviteEnterpriseAdminInputBuilder
    implements
        Builder<GInviteEnterpriseAdminInput,
            GInviteEnterpriseAdminInputBuilder> {
  _$GInviteEnterpriseAdminInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _email;
  String? get email => _$this._email;
  set email(String? email) => _$this._email = email;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _invitee;
  String? get invitee => _$this._invitee;
  set invitee(String? invitee) => _$this._invitee = invitee;

  GEnterpriseAdministratorRole? _role;
  GEnterpriseAdministratorRole? get role => _$this._role;
  set role(GEnterpriseAdministratorRole? role) => _$this._role = role;

  GInviteEnterpriseAdminInputBuilder();

  GInviteEnterpriseAdminInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _email = $v.email;
      _enterpriseId = $v.enterpriseId;
      _invitee = $v.invitee;
      _role = $v.role;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GInviteEnterpriseAdminInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GInviteEnterpriseAdminInput;
  }

  @override
  void update(void Function(GInviteEnterpriseAdminInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GInviteEnterpriseAdminInput build() {
    final _$result = _$v ??
        new _$GInviteEnterpriseAdminInput._(
            clientMutationId: clientMutationId,
            email: email,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId, 'GInviteEnterpriseAdminInput', 'enterpriseId'),
            invitee: invitee,
            role: role);
    replace(_$result);
    return _$result;
  }
}

class _$GIpAllowListEntryOrder extends GIpAllowListEntryOrder {
  @override
  final GOrderDirection direction;
  @override
  final GIpAllowListEntryOrderField field;

  factory _$GIpAllowListEntryOrder(
          [void Function(GIpAllowListEntryOrderBuilder)? updates]) =>
      (new GIpAllowListEntryOrderBuilder()..update(updates)).build();

  _$GIpAllowListEntryOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GIpAllowListEntryOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GIpAllowListEntryOrder', 'field');
  }

  @override
  GIpAllowListEntryOrder rebuild(
          void Function(GIpAllowListEntryOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GIpAllowListEntryOrderBuilder toBuilder() =>
      new GIpAllowListEntryOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GIpAllowListEntryOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GIpAllowListEntryOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GIpAllowListEntryOrderBuilder
    implements Builder<GIpAllowListEntryOrder, GIpAllowListEntryOrderBuilder> {
  _$GIpAllowListEntryOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GIpAllowListEntryOrderField? _field;
  GIpAllowListEntryOrderField? get field => _$this._field;
  set field(GIpAllowListEntryOrderField? field) => _$this._field = field;

  GIpAllowListEntryOrderBuilder();

  GIpAllowListEntryOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GIpAllowListEntryOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GIpAllowListEntryOrder;
  }

  @override
  void update(void Function(GIpAllowListEntryOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GIpAllowListEntryOrder build() {
    final _$result = _$v ??
        new _$GIpAllowListEntryOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GIpAllowListEntryOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GIpAllowListEntryOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GIssueCommentOrder extends GIssueCommentOrder {
  @override
  final GOrderDirection direction;
  @override
  final GIssueCommentOrderField field;

  factory _$GIssueCommentOrder(
          [void Function(GIssueCommentOrderBuilder)? updates]) =>
      (new GIssueCommentOrderBuilder()..update(updates)).build();

  _$GIssueCommentOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GIssueCommentOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GIssueCommentOrder', 'field');
  }

  @override
  GIssueCommentOrder rebuild(
          void Function(GIssueCommentOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GIssueCommentOrderBuilder toBuilder() =>
      new GIssueCommentOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GIssueCommentOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GIssueCommentOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GIssueCommentOrderBuilder
    implements Builder<GIssueCommentOrder, GIssueCommentOrderBuilder> {
  _$GIssueCommentOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GIssueCommentOrderField? _field;
  GIssueCommentOrderField? get field => _$this._field;
  set field(GIssueCommentOrderField? field) => _$this._field = field;

  GIssueCommentOrderBuilder();

  GIssueCommentOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GIssueCommentOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GIssueCommentOrder;
  }

  @override
  void update(void Function(GIssueCommentOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GIssueCommentOrder build() {
    final _$result = _$v ??
        new _$GIssueCommentOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GIssueCommentOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GIssueCommentOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GIssueFilters extends GIssueFilters {
  @override
  final String? assignee;
  @override
  final String? createdBy;
  @override
  final BuiltList<String>? labels;
  @override
  final String? mentioned;
  @override
  final String? milestone;
  @override
  final DateTime? since;
  @override
  final BuiltList<GIssueState>? states;
  @override
  final bool? viewerSubscribed;

  factory _$GIssueFilters([void Function(GIssueFiltersBuilder)? updates]) =>
      (new GIssueFiltersBuilder()..update(updates)).build();

  _$GIssueFilters._(
      {this.assignee,
      this.createdBy,
      this.labels,
      this.mentioned,
      this.milestone,
      this.since,
      this.states,
      this.viewerSubscribed})
      : super._();

  @override
  GIssueFilters rebuild(void Function(GIssueFiltersBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GIssueFiltersBuilder toBuilder() => new GIssueFiltersBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GIssueFilters &&
        assignee == other.assignee &&
        createdBy == other.createdBy &&
        labels == other.labels &&
        mentioned == other.mentioned &&
        milestone == other.milestone &&
        since == other.since &&
        states == other.states &&
        viewerSubscribed == other.viewerSubscribed;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc($jc($jc(0, assignee.hashCode), createdBy.hashCode),
                            labels.hashCode),
                        mentioned.hashCode),
                    milestone.hashCode),
                since.hashCode),
            states.hashCode),
        viewerSubscribed.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GIssueFilters')
          ..add('assignee', assignee)
          ..add('createdBy', createdBy)
          ..add('labels', labels)
          ..add('mentioned', mentioned)
          ..add('milestone', milestone)
          ..add('since', since)
          ..add('states', states)
          ..add('viewerSubscribed', viewerSubscribed))
        .toString();
  }
}

class GIssueFiltersBuilder
    implements Builder<GIssueFilters, GIssueFiltersBuilder> {
  _$GIssueFilters? _$v;

  String? _assignee;
  String? get assignee => _$this._assignee;
  set assignee(String? assignee) => _$this._assignee = assignee;

  String? _createdBy;
  String? get createdBy => _$this._createdBy;
  set createdBy(String? createdBy) => _$this._createdBy = createdBy;

  ListBuilder<String>? _labels;
  ListBuilder<String> get labels =>
      _$this._labels ??= new ListBuilder<String>();
  set labels(ListBuilder<String>? labels) => _$this._labels = labels;

  String? _mentioned;
  String? get mentioned => _$this._mentioned;
  set mentioned(String? mentioned) => _$this._mentioned = mentioned;

  String? _milestone;
  String? get milestone => _$this._milestone;
  set milestone(String? milestone) => _$this._milestone = milestone;

  DateTime? _since;
  DateTime? get since => _$this._since;
  set since(DateTime? since) => _$this._since = since;

  ListBuilder<GIssueState>? _states;
  ListBuilder<GIssueState> get states =>
      _$this._states ??= new ListBuilder<GIssueState>();
  set states(ListBuilder<GIssueState>? states) => _$this._states = states;

  bool? _viewerSubscribed;
  bool? get viewerSubscribed => _$this._viewerSubscribed;
  set viewerSubscribed(bool? viewerSubscribed) =>
      _$this._viewerSubscribed = viewerSubscribed;

  GIssueFiltersBuilder();

  GIssueFiltersBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _assignee = $v.assignee;
      _createdBy = $v.createdBy;
      _labels = $v.labels?.toBuilder();
      _mentioned = $v.mentioned;
      _milestone = $v.milestone;
      _since = $v.since;
      _states = $v.states?.toBuilder();
      _viewerSubscribed = $v.viewerSubscribed;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GIssueFilters other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GIssueFilters;
  }

  @override
  void update(void Function(GIssueFiltersBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GIssueFilters build() {
    _$GIssueFilters _$result;
    try {
      _$result = _$v ??
          new _$GIssueFilters._(
              assignee: assignee,
              createdBy: createdBy,
              labels: _labels?.build(),
              mentioned: mentioned,
              milestone: milestone,
              since: since,
              states: _states?.build(),
              viewerSubscribed: viewerSubscribed);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'labels';
        _labels?.build();

        _$failedField = 'states';
        _states?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GIssueFilters', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GIssueOrder extends GIssueOrder {
  @override
  final GOrderDirection direction;
  @override
  final GIssueOrderField field;

  factory _$GIssueOrder([void Function(GIssueOrderBuilder)? updates]) =>
      (new GIssueOrderBuilder()..update(updates)).build();

  _$GIssueOrder._({required this.direction, required this.field}) : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GIssueOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GIssueOrder', 'field');
  }

  @override
  GIssueOrder rebuild(void Function(GIssueOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GIssueOrderBuilder toBuilder() => new GIssueOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GIssueOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GIssueOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GIssueOrderBuilder implements Builder<GIssueOrder, GIssueOrderBuilder> {
  _$GIssueOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GIssueOrderField? _field;
  GIssueOrderField? get field => _$this._field;
  set field(GIssueOrderField? field) => _$this._field = field;

  GIssueOrderBuilder();

  GIssueOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GIssueOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GIssueOrder;
  }

  @override
  void update(void Function(GIssueOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GIssueOrder build() {
    final _$result = _$v ??
        new _$GIssueOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GIssueOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GIssueOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GLabelOrder extends GLabelOrder {
  @override
  final GOrderDirection direction;
  @override
  final GLabelOrderField field;

  factory _$GLabelOrder([void Function(GLabelOrderBuilder)? updates]) =>
      (new GLabelOrderBuilder()..update(updates)).build();

  _$GLabelOrder._({required this.direction, required this.field}) : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GLabelOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GLabelOrder', 'field');
  }

  @override
  GLabelOrder rebuild(void Function(GLabelOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GLabelOrderBuilder toBuilder() => new GLabelOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GLabelOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GLabelOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GLabelOrderBuilder implements Builder<GLabelOrder, GLabelOrderBuilder> {
  _$GLabelOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GLabelOrderField? _field;
  GLabelOrderField? get field => _$this._field;
  set field(GLabelOrderField? field) => _$this._field = field;

  GLabelOrderBuilder();

  GLabelOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLabelOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GLabelOrder;
  }

  @override
  void update(void Function(GLabelOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GLabelOrder build() {
    final _$result = _$v ??
        new _$GLabelOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GLabelOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GLabelOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GLanguageOrder extends GLanguageOrder {
  @override
  final GOrderDirection direction;
  @override
  final GLanguageOrderField field;

  factory _$GLanguageOrder([void Function(GLanguageOrderBuilder)? updates]) =>
      (new GLanguageOrderBuilder()..update(updates)).build();

  _$GLanguageOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GLanguageOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GLanguageOrder', 'field');
  }

  @override
  GLanguageOrder rebuild(void Function(GLanguageOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GLanguageOrderBuilder toBuilder() =>
      new GLanguageOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GLanguageOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GLanguageOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GLanguageOrderBuilder
    implements Builder<GLanguageOrder, GLanguageOrderBuilder> {
  _$GLanguageOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GLanguageOrderField? _field;
  GLanguageOrderField? get field => _$this._field;
  set field(GLanguageOrderField? field) => _$this._field = field;

  GLanguageOrderBuilder();

  GLanguageOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLanguageOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GLanguageOrder;
  }

  @override
  void update(void Function(GLanguageOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GLanguageOrder build() {
    final _$result = _$v ??
        new _$GLanguageOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GLanguageOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GLanguageOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GLinkRepositoryToProjectInput extends GLinkRepositoryToProjectInput {
  @override
  final String? clientMutationId;
  @override
  final String projectId;
  @override
  final String repositoryId;

  factory _$GLinkRepositoryToProjectInput(
          [void Function(GLinkRepositoryToProjectInputBuilder)? updates]) =>
      (new GLinkRepositoryToProjectInputBuilder()..update(updates)).build();

  _$GLinkRepositoryToProjectInput._(
      {this.clientMutationId,
      required this.projectId,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        projectId, 'GLinkRepositoryToProjectInput', 'projectId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GLinkRepositoryToProjectInput', 'repositoryId');
  }

  @override
  GLinkRepositoryToProjectInput rebuild(
          void Function(GLinkRepositoryToProjectInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GLinkRepositoryToProjectInputBuilder toBuilder() =>
      new GLinkRepositoryToProjectInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GLinkRepositoryToProjectInput &&
        clientMutationId == other.clientMutationId &&
        projectId == other.projectId &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), projectId.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GLinkRepositoryToProjectInput')
          ..add('clientMutationId', clientMutationId)
          ..add('projectId', projectId)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GLinkRepositoryToProjectInputBuilder
    implements
        Builder<GLinkRepositoryToProjectInput,
            GLinkRepositoryToProjectInputBuilder> {
  _$GLinkRepositoryToProjectInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _projectId;
  String? get projectId => _$this._projectId;
  set projectId(String? projectId) => _$this._projectId = projectId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GLinkRepositoryToProjectInputBuilder();

  GLinkRepositoryToProjectInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _projectId = $v.projectId;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLinkRepositoryToProjectInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GLinkRepositoryToProjectInput;
  }

  @override
  void update(void Function(GLinkRepositoryToProjectInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GLinkRepositoryToProjectInput build() {
    final _$result = _$v ??
        new _$GLinkRepositoryToProjectInput._(
            clientMutationId: clientMutationId,
            projectId: BuiltValueNullFieldError.checkNotNull(
                projectId, 'GLinkRepositoryToProjectInput', 'projectId'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GLinkRepositoryToProjectInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GLockLockableInput extends GLockLockableInput {
  @override
  final String? clientMutationId;
  @override
  final GLockReason? lockReason;
  @override
  final String lockableId;

  factory _$GLockLockableInput(
          [void Function(GLockLockableInputBuilder)? updates]) =>
      (new GLockLockableInputBuilder()..update(updates)).build();

  _$GLockLockableInput._(
      {this.clientMutationId, this.lockReason, required this.lockableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        lockableId, 'GLockLockableInput', 'lockableId');
  }

  @override
  GLockLockableInput rebuild(
          void Function(GLockLockableInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GLockLockableInputBuilder toBuilder() =>
      new GLockLockableInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GLockLockableInput &&
        clientMutationId == other.clientMutationId &&
        lockReason == other.lockReason &&
        lockableId == other.lockableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), lockReason.hashCode),
        lockableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GLockLockableInput')
          ..add('clientMutationId', clientMutationId)
          ..add('lockReason', lockReason)
          ..add('lockableId', lockableId))
        .toString();
  }
}

class GLockLockableInputBuilder
    implements Builder<GLockLockableInput, GLockLockableInputBuilder> {
  _$GLockLockableInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GLockReason? _lockReason;
  GLockReason? get lockReason => _$this._lockReason;
  set lockReason(GLockReason? lockReason) => _$this._lockReason = lockReason;

  String? _lockableId;
  String? get lockableId => _$this._lockableId;
  set lockableId(String? lockableId) => _$this._lockableId = lockableId;

  GLockLockableInputBuilder();

  GLockLockableInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _lockReason = $v.lockReason;
      _lockableId = $v.lockableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLockLockableInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GLockLockableInput;
  }

  @override
  void update(void Function(GLockLockableInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GLockLockableInput build() {
    final _$result = _$v ??
        new _$GLockLockableInput._(
            clientMutationId: clientMutationId,
            lockReason: lockReason,
            lockableId: BuiltValueNullFieldError.checkNotNull(
                lockableId, 'GLockLockableInput', 'lockableId'));
    replace(_$result);
    return _$result;
  }
}

class _$GMarkDiscussionCommentAsAnswerInput
    extends GMarkDiscussionCommentAsAnswerInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GMarkDiscussionCommentAsAnswerInput(
          [void Function(GMarkDiscussionCommentAsAnswerInputBuilder)?
              updates]) =>
      (new GMarkDiscussionCommentAsAnswerInputBuilder()..update(updates))
          .build();

  _$GMarkDiscussionCommentAsAnswerInput._(
      {this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GMarkDiscussionCommentAsAnswerInput', 'id');
  }

  @override
  GMarkDiscussionCommentAsAnswerInput rebuild(
          void Function(GMarkDiscussionCommentAsAnswerInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMarkDiscussionCommentAsAnswerInputBuilder toBuilder() =>
      new GMarkDiscussionCommentAsAnswerInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMarkDiscussionCommentAsAnswerInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMarkDiscussionCommentAsAnswerInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GMarkDiscussionCommentAsAnswerInputBuilder
    implements
        Builder<GMarkDiscussionCommentAsAnswerInput,
            GMarkDiscussionCommentAsAnswerInputBuilder> {
  _$GMarkDiscussionCommentAsAnswerInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GMarkDiscussionCommentAsAnswerInputBuilder();

  GMarkDiscussionCommentAsAnswerInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMarkDiscussionCommentAsAnswerInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMarkDiscussionCommentAsAnswerInput;
  }

  @override
  void update(
      void Function(GMarkDiscussionCommentAsAnswerInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMarkDiscussionCommentAsAnswerInput build() {
    final _$result = _$v ??
        new _$GMarkDiscussionCommentAsAnswerInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GMarkDiscussionCommentAsAnswerInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GMarkFileAsViewedInput extends GMarkFileAsViewedInput {
  @override
  final String? clientMutationId;
  @override
  final String path;
  @override
  final String pullRequestId;

  factory _$GMarkFileAsViewedInput(
          [void Function(GMarkFileAsViewedInputBuilder)? updates]) =>
      (new GMarkFileAsViewedInputBuilder()..update(updates)).build();

  _$GMarkFileAsViewedInput._(
      {this.clientMutationId, required this.path, required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        path, 'GMarkFileAsViewedInput', 'path');
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GMarkFileAsViewedInput', 'pullRequestId');
  }

  @override
  GMarkFileAsViewedInput rebuild(
          void Function(GMarkFileAsViewedInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMarkFileAsViewedInputBuilder toBuilder() =>
      new GMarkFileAsViewedInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMarkFileAsViewedInput &&
        clientMutationId == other.clientMutationId &&
        path == other.path &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), path.hashCode),
        pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMarkFileAsViewedInput')
          ..add('clientMutationId', clientMutationId)
          ..add('path', path)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GMarkFileAsViewedInputBuilder
    implements Builder<GMarkFileAsViewedInput, GMarkFileAsViewedInputBuilder> {
  _$GMarkFileAsViewedInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _path;
  String? get path => _$this._path;
  set path(String? path) => _$this._path = path;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GMarkFileAsViewedInputBuilder();

  GMarkFileAsViewedInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _path = $v.path;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMarkFileAsViewedInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMarkFileAsViewedInput;
  }

  @override
  void update(void Function(GMarkFileAsViewedInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMarkFileAsViewedInput build() {
    final _$result = _$v ??
        new _$GMarkFileAsViewedInput._(
            clientMutationId: clientMutationId,
            path: BuiltValueNullFieldError.checkNotNull(
                path, 'GMarkFileAsViewedInput', 'path'),
            pullRequestId: BuiltValueNullFieldError.checkNotNull(
                pullRequestId, 'GMarkFileAsViewedInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GMarkPullRequestReadyForReviewInput
    extends GMarkPullRequestReadyForReviewInput {
  @override
  final String? clientMutationId;
  @override
  final String pullRequestId;

  factory _$GMarkPullRequestReadyForReviewInput(
          [void Function(GMarkPullRequestReadyForReviewInputBuilder)?
              updates]) =>
      (new GMarkPullRequestReadyForReviewInputBuilder()..update(updates))
          .build();

  _$GMarkPullRequestReadyForReviewInput._(
      {this.clientMutationId, required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GMarkPullRequestReadyForReviewInput', 'pullRequestId');
  }

  @override
  GMarkPullRequestReadyForReviewInput rebuild(
          void Function(GMarkPullRequestReadyForReviewInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMarkPullRequestReadyForReviewInputBuilder toBuilder() =>
      new GMarkPullRequestReadyForReviewInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMarkPullRequestReadyForReviewInput &&
        clientMutationId == other.clientMutationId &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMarkPullRequestReadyForReviewInput')
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GMarkPullRequestReadyForReviewInputBuilder
    implements
        Builder<GMarkPullRequestReadyForReviewInput,
            GMarkPullRequestReadyForReviewInputBuilder> {
  _$GMarkPullRequestReadyForReviewInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GMarkPullRequestReadyForReviewInputBuilder();

  GMarkPullRequestReadyForReviewInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMarkPullRequestReadyForReviewInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMarkPullRequestReadyForReviewInput;
  }

  @override
  void update(
      void Function(GMarkPullRequestReadyForReviewInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMarkPullRequestReadyForReviewInput build() {
    final _$result = _$v ??
        new _$GMarkPullRequestReadyForReviewInput._(
            clientMutationId: clientMutationId,
            pullRequestId: BuiltValueNullFieldError.checkNotNull(pullRequestId,
                'GMarkPullRequestReadyForReviewInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GMergeBranchInput extends GMergeBranchInput {
  @override
  final String? authorEmail;
  @override
  final String base;
  @override
  final String? clientMutationId;
  @override
  final String? commitMessage;
  @override
  final String head;
  @override
  final String repositoryId;

  factory _$GMergeBranchInput(
          [void Function(GMergeBranchInputBuilder)? updates]) =>
      (new GMergeBranchInputBuilder()..update(updates)).build();

  _$GMergeBranchInput._(
      {this.authorEmail,
      required this.base,
      this.clientMutationId,
      this.commitMessage,
      required this.head,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(base, 'GMergeBranchInput', 'base');
    BuiltValueNullFieldError.checkNotNull(head, 'GMergeBranchInput', 'head');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GMergeBranchInput', 'repositoryId');
  }

  @override
  GMergeBranchInput rebuild(void Function(GMergeBranchInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMergeBranchInputBuilder toBuilder() =>
      new GMergeBranchInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMergeBranchInput &&
        authorEmail == other.authorEmail &&
        base == other.base &&
        clientMutationId == other.clientMutationId &&
        commitMessage == other.commitMessage &&
        head == other.head &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc($jc($jc(0, authorEmail.hashCode), base.hashCode),
                    clientMutationId.hashCode),
                commitMessage.hashCode),
            head.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMergeBranchInput')
          ..add('authorEmail', authorEmail)
          ..add('base', base)
          ..add('clientMutationId', clientMutationId)
          ..add('commitMessage', commitMessage)
          ..add('head', head)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GMergeBranchInputBuilder
    implements Builder<GMergeBranchInput, GMergeBranchInputBuilder> {
  _$GMergeBranchInput? _$v;

  String? _authorEmail;
  String? get authorEmail => _$this._authorEmail;
  set authorEmail(String? authorEmail) => _$this._authorEmail = authorEmail;

  String? _base;
  String? get base => _$this._base;
  set base(String? base) => _$this._base = base;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _commitMessage;
  String? get commitMessage => _$this._commitMessage;
  set commitMessage(String? commitMessage) =>
      _$this._commitMessage = commitMessage;

  String? _head;
  String? get head => _$this._head;
  set head(String? head) => _$this._head = head;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GMergeBranchInputBuilder();

  GMergeBranchInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _authorEmail = $v.authorEmail;
      _base = $v.base;
      _clientMutationId = $v.clientMutationId;
      _commitMessage = $v.commitMessage;
      _head = $v.head;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMergeBranchInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMergeBranchInput;
  }

  @override
  void update(void Function(GMergeBranchInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMergeBranchInput build() {
    final _$result = _$v ??
        new _$GMergeBranchInput._(
            authorEmail: authorEmail,
            base: BuiltValueNullFieldError.checkNotNull(
                base, 'GMergeBranchInput', 'base'),
            clientMutationId: clientMutationId,
            commitMessage: commitMessage,
            head: BuiltValueNullFieldError.checkNotNull(
                head, 'GMergeBranchInput', 'head'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GMergeBranchInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GMergePullRequestInput extends GMergePullRequestInput {
  @override
  final String? authorEmail;
  @override
  final String? clientMutationId;
  @override
  final String? commitBody;
  @override
  final String? commitHeadline;
  @override
  final String? expectedHeadOid;
  @override
  final GPullRequestMergeMethod? mergeMethod;
  @override
  final String pullRequestId;

  factory _$GMergePullRequestInput(
          [void Function(GMergePullRequestInputBuilder)? updates]) =>
      (new GMergePullRequestInputBuilder()..update(updates)).build();

  _$GMergePullRequestInput._(
      {this.authorEmail,
      this.clientMutationId,
      this.commitBody,
      this.commitHeadline,
      this.expectedHeadOid,
      this.mergeMethod,
      required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GMergePullRequestInput', 'pullRequestId');
  }

  @override
  GMergePullRequestInput rebuild(
          void Function(GMergePullRequestInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMergePullRequestInputBuilder toBuilder() =>
      new GMergePullRequestInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMergePullRequestInput &&
        authorEmail == other.authorEmail &&
        clientMutationId == other.clientMutationId &&
        commitBody == other.commitBody &&
        commitHeadline == other.commitHeadline &&
        expectedHeadOid == other.expectedHeadOid &&
        mergeMethod == other.mergeMethod &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc($jc(0, authorEmail.hashCode),
                            clientMutationId.hashCode),
                        commitBody.hashCode),
                    commitHeadline.hashCode),
                expectedHeadOid.hashCode),
            mergeMethod.hashCode),
        pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMergePullRequestInput')
          ..add('authorEmail', authorEmail)
          ..add('clientMutationId', clientMutationId)
          ..add('commitBody', commitBody)
          ..add('commitHeadline', commitHeadline)
          ..add('expectedHeadOid', expectedHeadOid)
          ..add('mergeMethod', mergeMethod)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GMergePullRequestInputBuilder
    implements Builder<GMergePullRequestInput, GMergePullRequestInputBuilder> {
  _$GMergePullRequestInput? _$v;

  String? _authorEmail;
  String? get authorEmail => _$this._authorEmail;
  set authorEmail(String? authorEmail) => _$this._authorEmail = authorEmail;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _commitBody;
  String? get commitBody => _$this._commitBody;
  set commitBody(String? commitBody) => _$this._commitBody = commitBody;

  String? _commitHeadline;
  String? get commitHeadline => _$this._commitHeadline;
  set commitHeadline(String? commitHeadline) =>
      _$this._commitHeadline = commitHeadline;

  String? _expectedHeadOid;
  String? get expectedHeadOid => _$this._expectedHeadOid;
  set expectedHeadOid(String? expectedHeadOid) =>
      _$this._expectedHeadOid = expectedHeadOid;

  GPullRequestMergeMethod? _mergeMethod;
  GPullRequestMergeMethod? get mergeMethod => _$this._mergeMethod;
  set mergeMethod(GPullRequestMergeMethod? mergeMethod) =>
      _$this._mergeMethod = mergeMethod;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GMergePullRequestInputBuilder();

  GMergePullRequestInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _authorEmail = $v.authorEmail;
      _clientMutationId = $v.clientMutationId;
      _commitBody = $v.commitBody;
      _commitHeadline = $v.commitHeadline;
      _expectedHeadOid = $v.expectedHeadOid;
      _mergeMethod = $v.mergeMethod;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMergePullRequestInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMergePullRequestInput;
  }

  @override
  void update(void Function(GMergePullRequestInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMergePullRequestInput build() {
    final _$result = _$v ??
        new _$GMergePullRequestInput._(
            authorEmail: authorEmail,
            clientMutationId: clientMutationId,
            commitBody: commitBody,
            commitHeadline: commitHeadline,
            expectedHeadOid: expectedHeadOid,
            mergeMethod: mergeMethod,
            pullRequestId: BuiltValueNullFieldError.checkNotNull(
                pullRequestId, 'GMergePullRequestInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GMilestoneOrder extends GMilestoneOrder {
  @override
  final GOrderDirection direction;
  @override
  final GMilestoneOrderField field;

  factory _$GMilestoneOrder([void Function(GMilestoneOrderBuilder)? updates]) =>
      (new GMilestoneOrderBuilder()..update(updates)).build();

  _$GMilestoneOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GMilestoneOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GMilestoneOrder', 'field');
  }

  @override
  GMilestoneOrder rebuild(void Function(GMilestoneOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMilestoneOrderBuilder toBuilder() =>
      new GMilestoneOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMilestoneOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMilestoneOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GMilestoneOrderBuilder
    implements Builder<GMilestoneOrder, GMilestoneOrderBuilder> {
  _$GMilestoneOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GMilestoneOrderField? _field;
  GMilestoneOrderField? get field => _$this._field;
  set field(GMilestoneOrderField? field) => _$this._field = field;

  GMilestoneOrderBuilder();

  GMilestoneOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMilestoneOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMilestoneOrder;
  }

  @override
  void update(void Function(GMilestoneOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMilestoneOrder build() {
    final _$result = _$v ??
        new _$GMilestoneOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GMilestoneOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GMilestoneOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GMinimizeCommentInput extends GMinimizeCommentInput {
  @override
  final GReportedContentClassifiers classifier;
  @override
  final String? clientMutationId;
  @override
  final String subjectId;

  factory _$GMinimizeCommentInput(
          [void Function(GMinimizeCommentInputBuilder)? updates]) =>
      (new GMinimizeCommentInputBuilder()..update(updates)).build();

  _$GMinimizeCommentInput._(
      {required this.classifier,
      this.clientMutationId,
      required this.subjectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        classifier, 'GMinimizeCommentInput', 'classifier');
    BuiltValueNullFieldError.checkNotNull(
        subjectId, 'GMinimizeCommentInput', 'subjectId');
  }

  @override
  GMinimizeCommentInput rebuild(
          void Function(GMinimizeCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMinimizeCommentInputBuilder toBuilder() =>
      new GMinimizeCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMinimizeCommentInput &&
        classifier == other.classifier &&
        clientMutationId == other.clientMutationId &&
        subjectId == other.subjectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, classifier.hashCode), clientMutationId.hashCode),
        subjectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMinimizeCommentInput')
          ..add('classifier', classifier)
          ..add('clientMutationId', clientMutationId)
          ..add('subjectId', subjectId))
        .toString();
  }
}

class GMinimizeCommentInputBuilder
    implements Builder<GMinimizeCommentInput, GMinimizeCommentInputBuilder> {
  _$GMinimizeCommentInput? _$v;

  GReportedContentClassifiers? _classifier;
  GReportedContentClassifiers? get classifier => _$this._classifier;
  set classifier(GReportedContentClassifiers? classifier) =>
      _$this._classifier = classifier;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _subjectId;
  String? get subjectId => _$this._subjectId;
  set subjectId(String? subjectId) => _$this._subjectId = subjectId;

  GMinimizeCommentInputBuilder();

  GMinimizeCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _classifier = $v.classifier;
      _clientMutationId = $v.clientMutationId;
      _subjectId = $v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMinimizeCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMinimizeCommentInput;
  }

  @override
  void update(void Function(GMinimizeCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMinimizeCommentInput build() {
    final _$result = _$v ??
        new _$GMinimizeCommentInput._(
            classifier: BuiltValueNullFieldError.checkNotNull(
                classifier, 'GMinimizeCommentInput', 'classifier'),
            clientMutationId: clientMutationId,
            subjectId: BuiltValueNullFieldError.checkNotNull(
                subjectId, 'GMinimizeCommentInput', 'subjectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GMoveProjectCardInput extends GMoveProjectCardInput {
  @override
  final String? afterCardId;
  @override
  final String cardId;
  @override
  final String? clientMutationId;
  @override
  final String columnId;

  factory _$GMoveProjectCardInput(
          [void Function(GMoveProjectCardInputBuilder)? updates]) =>
      (new GMoveProjectCardInputBuilder()..update(updates)).build();

  _$GMoveProjectCardInput._(
      {this.afterCardId,
      required this.cardId,
      this.clientMutationId,
      required this.columnId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        cardId, 'GMoveProjectCardInput', 'cardId');
    BuiltValueNullFieldError.checkNotNull(
        columnId, 'GMoveProjectCardInput', 'columnId');
  }

  @override
  GMoveProjectCardInput rebuild(
          void Function(GMoveProjectCardInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMoveProjectCardInputBuilder toBuilder() =>
      new GMoveProjectCardInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMoveProjectCardInput &&
        afterCardId == other.afterCardId &&
        cardId == other.cardId &&
        clientMutationId == other.clientMutationId &&
        columnId == other.columnId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, afterCardId.hashCode), cardId.hashCode),
            clientMutationId.hashCode),
        columnId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMoveProjectCardInput')
          ..add('afterCardId', afterCardId)
          ..add('cardId', cardId)
          ..add('clientMutationId', clientMutationId)
          ..add('columnId', columnId))
        .toString();
  }
}

class GMoveProjectCardInputBuilder
    implements Builder<GMoveProjectCardInput, GMoveProjectCardInputBuilder> {
  _$GMoveProjectCardInput? _$v;

  String? _afterCardId;
  String? get afterCardId => _$this._afterCardId;
  set afterCardId(String? afterCardId) => _$this._afterCardId = afterCardId;

  String? _cardId;
  String? get cardId => _$this._cardId;
  set cardId(String? cardId) => _$this._cardId = cardId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _columnId;
  String? get columnId => _$this._columnId;
  set columnId(String? columnId) => _$this._columnId = columnId;

  GMoveProjectCardInputBuilder();

  GMoveProjectCardInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _afterCardId = $v.afterCardId;
      _cardId = $v.cardId;
      _clientMutationId = $v.clientMutationId;
      _columnId = $v.columnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMoveProjectCardInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMoveProjectCardInput;
  }

  @override
  void update(void Function(GMoveProjectCardInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMoveProjectCardInput build() {
    final _$result = _$v ??
        new _$GMoveProjectCardInput._(
            afterCardId: afterCardId,
            cardId: BuiltValueNullFieldError.checkNotNull(
                cardId, 'GMoveProjectCardInput', 'cardId'),
            clientMutationId: clientMutationId,
            columnId: BuiltValueNullFieldError.checkNotNull(
                columnId, 'GMoveProjectCardInput', 'columnId'));
    replace(_$result);
    return _$result;
  }
}

class _$GMoveProjectColumnInput extends GMoveProjectColumnInput {
  @override
  final String? afterColumnId;
  @override
  final String? clientMutationId;
  @override
  final String columnId;

  factory _$GMoveProjectColumnInput(
          [void Function(GMoveProjectColumnInputBuilder)? updates]) =>
      (new GMoveProjectColumnInputBuilder()..update(updates)).build();

  _$GMoveProjectColumnInput._(
      {this.afterColumnId, this.clientMutationId, required this.columnId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        columnId, 'GMoveProjectColumnInput', 'columnId');
  }

  @override
  GMoveProjectColumnInput rebuild(
          void Function(GMoveProjectColumnInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GMoveProjectColumnInputBuilder toBuilder() =>
      new GMoveProjectColumnInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GMoveProjectColumnInput &&
        afterColumnId == other.afterColumnId &&
        clientMutationId == other.clientMutationId &&
        columnId == other.columnId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, afterColumnId.hashCode), clientMutationId.hashCode),
        columnId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GMoveProjectColumnInput')
          ..add('afterColumnId', afterColumnId)
          ..add('clientMutationId', clientMutationId)
          ..add('columnId', columnId))
        .toString();
  }
}

class GMoveProjectColumnInputBuilder
    implements
        Builder<GMoveProjectColumnInput, GMoveProjectColumnInputBuilder> {
  _$GMoveProjectColumnInput? _$v;

  String? _afterColumnId;
  String? get afterColumnId => _$this._afterColumnId;
  set afterColumnId(String? afterColumnId) =>
      _$this._afterColumnId = afterColumnId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _columnId;
  String? get columnId => _$this._columnId;
  set columnId(String? columnId) => _$this._columnId = columnId;

  GMoveProjectColumnInputBuilder();

  GMoveProjectColumnInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _afterColumnId = $v.afterColumnId;
      _clientMutationId = $v.clientMutationId;
      _columnId = $v.columnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMoveProjectColumnInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GMoveProjectColumnInput;
  }

  @override
  void update(void Function(GMoveProjectColumnInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GMoveProjectColumnInput build() {
    final _$result = _$v ??
        new _$GMoveProjectColumnInput._(
            afterColumnId: afterColumnId,
            clientMutationId: clientMutationId,
            columnId: BuiltValueNullFieldError.checkNotNull(
                columnId, 'GMoveProjectColumnInput', 'columnId'));
    replace(_$result);
    return _$result;
  }
}

class _$GOrganizationOrder extends GOrganizationOrder {
  @override
  final GOrderDirection direction;
  @override
  final GOrganizationOrderField field;

  factory _$GOrganizationOrder(
          [void Function(GOrganizationOrderBuilder)? updates]) =>
      (new GOrganizationOrderBuilder()..update(updates)).build();

  _$GOrganizationOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GOrganizationOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GOrganizationOrder', 'field');
  }

  @override
  GOrganizationOrder rebuild(
          void Function(GOrganizationOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GOrganizationOrderBuilder toBuilder() =>
      new GOrganizationOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GOrganizationOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GOrganizationOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GOrganizationOrderBuilder
    implements Builder<GOrganizationOrder, GOrganizationOrderBuilder> {
  _$GOrganizationOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GOrganizationOrderField? _field;
  GOrganizationOrderField? get field => _$this._field;
  set field(GOrganizationOrderField? field) => _$this._field = field;

  GOrganizationOrderBuilder();

  GOrganizationOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GOrganizationOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GOrganizationOrder;
  }

  @override
  void update(void Function(GOrganizationOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GOrganizationOrder build() {
    final _$result = _$v ??
        new _$GOrganizationOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GOrganizationOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GOrganizationOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GPackageFileOrder extends GPackageFileOrder {
  @override
  final GOrderDirection? direction;
  @override
  final GPackageFileOrderField? field;

  factory _$GPackageFileOrder(
          [void Function(GPackageFileOrderBuilder)? updates]) =>
      (new GPackageFileOrderBuilder()..update(updates)).build();

  _$GPackageFileOrder._({this.direction, this.field}) : super._();

  @override
  GPackageFileOrder rebuild(void Function(GPackageFileOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GPackageFileOrderBuilder toBuilder() =>
      new GPackageFileOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GPackageFileOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GPackageFileOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GPackageFileOrderBuilder
    implements Builder<GPackageFileOrder, GPackageFileOrderBuilder> {
  _$GPackageFileOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GPackageFileOrderField? _field;
  GPackageFileOrderField? get field => _$this._field;
  set field(GPackageFileOrderField? field) => _$this._field = field;

  GPackageFileOrderBuilder();

  GPackageFileOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPackageFileOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GPackageFileOrder;
  }

  @override
  void update(void Function(GPackageFileOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GPackageFileOrder build() {
    final _$result =
        _$v ?? new _$GPackageFileOrder._(direction: direction, field: field);
    replace(_$result);
    return _$result;
  }
}

class _$GPackageOrder extends GPackageOrder {
  @override
  final GOrderDirection? direction;
  @override
  final GPackageOrderField? field;

  factory _$GPackageOrder([void Function(GPackageOrderBuilder)? updates]) =>
      (new GPackageOrderBuilder()..update(updates)).build();

  _$GPackageOrder._({this.direction, this.field}) : super._();

  @override
  GPackageOrder rebuild(void Function(GPackageOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GPackageOrderBuilder toBuilder() => new GPackageOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GPackageOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GPackageOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GPackageOrderBuilder
    implements Builder<GPackageOrder, GPackageOrderBuilder> {
  _$GPackageOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GPackageOrderField? _field;
  GPackageOrderField? get field => _$this._field;
  set field(GPackageOrderField? field) => _$this._field = field;

  GPackageOrderBuilder();

  GPackageOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPackageOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GPackageOrder;
  }

  @override
  void update(void Function(GPackageOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GPackageOrder build() {
    final _$result =
        _$v ?? new _$GPackageOrder._(direction: direction, field: field);
    replace(_$result);
    return _$result;
  }
}

class _$GPackageVersionOrder extends GPackageVersionOrder {
  @override
  final GOrderDirection? direction;
  @override
  final GPackageVersionOrderField? field;

  factory _$GPackageVersionOrder(
          [void Function(GPackageVersionOrderBuilder)? updates]) =>
      (new GPackageVersionOrderBuilder()..update(updates)).build();

  _$GPackageVersionOrder._({this.direction, this.field}) : super._();

  @override
  GPackageVersionOrder rebuild(
          void Function(GPackageVersionOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GPackageVersionOrderBuilder toBuilder() =>
      new GPackageVersionOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GPackageVersionOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GPackageVersionOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GPackageVersionOrderBuilder
    implements Builder<GPackageVersionOrder, GPackageVersionOrderBuilder> {
  _$GPackageVersionOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GPackageVersionOrderField? _field;
  GPackageVersionOrderField? get field => _$this._field;
  set field(GPackageVersionOrderField? field) => _$this._field = field;

  GPackageVersionOrderBuilder();

  GPackageVersionOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPackageVersionOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GPackageVersionOrder;
  }

  @override
  void update(void Function(GPackageVersionOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GPackageVersionOrder build() {
    final _$result =
        _$v ?? new _$GPackageVersionOrder._(direction: direction, field: field);
    replace(_$result);
    return _$result;
  }
}

class _$GPinIssueInput extends GPinIssueInput {
  @override
  final String? clientMutationId;
  @override
  final String issueId;

  factory _$GPinIssueInput([void Function(GPinIssueInputBuilder)? updates]) =>
      (new GPinIssueInputBuilder()..update(updates)).build();

  _$GPinIssueInput._({this.clientMutationId, required this.issueId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(issueId, 'GPinIssueInput', 'issueId');
  }

  @override
  GPinIssueInput rebuild(void Function(GPinIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GPinIssueInputBuilder toBuilder() =>
      new GPinIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GPinIssueInput &&
        clientMutationId == other.clientMutationId &&
        issueId == other.issueId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), issueId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GPinIssueInput')
          ..add('clientMutationId', clientMutationId)
          ..add('issueId', issueId))
        .toString();
  }
}

class GPinIssueInputBuilder
    implements Builder<GPinIssueInput, GPinIssueInputBuilder> {
  _$GPinIssueInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _issueId;
  String? get issueId => _$this._issueId;
  set issueId(String? issueId) => _$this._issueId = issueId;

  GPinIssueInputBuilder();

  GPinIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _issueId = $v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPinIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GPinIssueInput;
  }

  @override
  void update(void Function(GPinIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GPinIssueInput build() {
    final _$result = _$v ??
        new _$GPinIssueInput._(
            clientMutationId: clientMutationId,
            issueId: BuiltValueNullFieldError.checkNotNull(
                issueId, 'GPinIssueInput', 'issueId'));
    replace(_$result);
    return _$result;
  }
}

class _$GPreciseDateTime extends GPreciseDateTime {
  @override
  final String value;

  factory _$GPreciseDateTime(
          [void Function(GPreciseDateTimeBuilder)? updates]) =>
      (new GPreciseDateTimeBuilder()..update(updates)).build();

  _$GPreciseDateTime._({required this.value}) : super._() {
    BuiltValueNullFieldError.checkNotNull(value, 'GPreciseDateTime', 'value');
  }

  @override
  GPreciseDateTime rebuild(void Function(GPreciseDateTimeBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GPreciseDateTimeBuilder toBuilder() =>
      new GPreciseDateTimeBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GPreciseDateTime && value == other.value;
  }

  @override
  int get hashCode {
    return $jf($jc(0, value.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GPreciseDateTime')
          ..add('value', value))
        .toString();
  }
}

class GPreciseDateTimeBuilder
    implements Builder<GPreciseDateTime, GPreciseDateTimeBuilder> {
  _$GPreciseDateTime? _$v;

  String? _value;
  String? get value => _$this._value;
  set value(String? value) => _$this._value = value;

  GPreciseDateTimeBuilder();

  GPreciseDateTimeBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPreciseDateTime other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GPreciseDateTime;
  }

  @override
  void update(void Function(GPreciseDateTimeBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GPreciseDateTime build() {
    final _$result = _$v ??
        new _$GPreciseDateTime._(
            value: BuiltValueNullFieldError.checkNotNull(
                value, 'GPreciseDateTime', 'value'));
    replace(_$result);
    return _$result;
  }
}

class _$GProjectOrder extends GProjectOrder {
  @override
  final GOrderDirection direction;
  @override
  final GProjectOrderField field;

  factory _$GProjectOrder([void Function(GProjectOrderBuilder)? updates]) =>
      (new GProjectOrderBuilder()..update(updates)).build();

  _$GProjectOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GProjectOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GProjectOrder', 'field');
  }

  @override
  GProjectOrder rebuild(void Function(GProjectOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GProjectOrderBuilder toBuilder() => new GProjectOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GProjectOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GProjectOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GProjectOrderBuilder
    implements Builder<GProjectOrder, GProjectOrderBuilder> {
  _$GProjectOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GProjectOrderField? _field;
  GProjectOrderField? get field => _$this._field;
  set field(GProjectOrderField? field) => _$this._field = field;

  GProjectOrderBuilder();

  GProjectOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GProjectOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GProjectOrder;
  }

  @override
  void update(void Function(GProjectOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GProjectOrder build() {
    final _$result = _$v ??
        new _$GProjectOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GProjectOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GProjectOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GPullRequestOrder extends GPullRequestOrder {
  @override
  final GOrderDirection direction;
  @override
  final GPullRequestOrderField field;

  factory _$GPullRequestOrder(
          [void Function(GPullRequestOrderBuilder)? updates]) =>
      (new GPullRequestOrderBuilder()..update(updates)).build();

  _$GPullRequestOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GPullRequestOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GPullRequestOrder', 'field');
  }

  @override
  GPullRequestOrder rebuild(void Function(GPullRequestOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GPullRequestOrderBuilder toBuilder() =>
      new GPullRequestOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GPullRequestOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GPullRequestOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GPullRequestOrderBuilder
    implements Builder<GPullRequestOrder, GPullRequestOrderBuilder> {
  _$GPullRequestOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GPullRequestOrderField? _field;
  GPullRequestOrderField? get field => _$this._field;
  set field(GPullRequestOrderField? field) => _$this._field = field;

  GPullRequestOrderBuilder();

  GPullRequestOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPullRequestOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GPullRequestOrder;
  }

  @override
  void update(void Function(GPullRequestOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GPullRequestOrder build() {
    final _$result = _$v ??
        new _$GPullRequestOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GPullRequestOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GPullRequestOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GReactionOrder extends GReactionOrder {
  @override
  final GOrderDirection direction;
  @override
  final GReactionOrderField field;

  factory _$GReactionOrder([void Function(GReactionOrderBuilder)? updates]) =>
      (new GReactionOrderBuilder()..update(updates)).build();

  _$GReactionOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GReactionOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GReactionOrder', 'field');
  }

  @override
  GReactionOrder rebuild(void Function(GReactionOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GReactionOrderBuilder toBuilder() =>
      new GReactionOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GReactionOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GReactionOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GReactionOrderBuilder
    implements Builder<GReactionOrder, GReactionOrderBuilder> {
  _$GReactionOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GReactionOrderField? _field;
  GReactionOrderField? get field => _$this._field;
  set field(GReactionOrderField? field) => _$this._field = field;

  GReactionOrderBuilder();

  GReactionOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReactionOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GReactionOrder;
  }

  @override
  void update(void Function(GReactionOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GReactionOrder build() {
    final _$result = _$v ??
        new _$GReactionOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GReactionOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GReactionOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GRefOrder extends GRefOrder {
  @override
  final GOrderDirection direction;
  @override
  final GRefOrderField field;

  factory _$GRefOrder([void Function(GRefOrderBuilder)? updates]) =>
      (new GRefOrderBuilder()..update(updates)).build();

  _$GRefOrder._({required this.direction, required this.field}) : super._() {
    BuiltValueNullFieldError.checkNotNull(direction, 'GRefOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GRefOrder', 'field');
  }

  @override
  GRefOrder rebuild(void Function(GRefOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRefOrderBuilder toBuilder() => new GRefOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRefOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRefOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GRefOrderBuilder implements Builder<GRefOrder, GRefOrderBuilder> {
  _$GRefOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GRefOrderField? _field;
  GRefOrderField? get field => _$this._field;
  set field(GRefOrderField? field) => _$this._field = field;

  GRefOrderBuilder();

  GRefOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRefOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRefOrder;
  }

  @override
  void update(void Function(GRefOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRefOrder build() {
    final _$result = _$v ??
        new _$GRefOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GRefOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GRefOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput
    extends GRegenerateEnterpriseIdentityProviderRecoveryCodesInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;

  factory _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput(
          [void Function(
                  GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder)?
              updates]) =>
      (new GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder()
            ..update(updates))
          .build();

  _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput._(
      {this.clientMutationId, required this.enterpriseId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GRegenerateEnterpriseIdentityProviderRecoveryCodesInput',
        'enterpriseId');
  }

  @override
  GRegenerateEnterpriseIdentityProviderRecoveryCodesInput rebuild(
          void Function(
                  GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder toBuilder() =>
      new GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder()
        ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRegenerateEnterpriseIdentityProviderRecoveryCodesInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GRegenerateEnterpriseIdentityProviderRecoveryCodesInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId))
        .toString();
  }
}

class GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder
    implements
        Builder<GRegenerateEnterpriseIdentityProviderRecoveryCodesInput,
            GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder> {
  _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder();

  GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRegenerateEnterpriseIdentityProviderRecoveryCodesInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput;
  }

  @override
  void update(
      void Function(
              GRegenerateEnterpriseIdentityProviderRecoveryCodesInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput build() {
    final _$result = _$v ??
        new _$GRegenerateEnterpriseIdentityProviderRecoveryCodesInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GRegenerateEnterpriseIdentityProviderRecoveryCodesInput',
                'enterpriseId'));
    replace(_$result);
    return _$result;
  }
}

class _$GRegenerateVerifiableDomainTokenInput
    extends GRegenerateVerifiableDomainTokenInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GRegenerateVerifiableDomainTokenInput(
          [void Function(GRegenerateVerifiableDomainTokenInputBuilder)?
              updates]) =>
      (new GRegenerateVerifiableDomainTokenInputBuilder()..update(updates))
          .build();

  _$GRegenerateVerifiableDomainTokenInput._(
      {this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GRegenerateVerifiableDomainTokenInput', 'id');
  }

  @override
  GRegenerateVerifiableDomainTokenInput rebuild(
          void Function(GRegenerateVerifiableDomainTokenInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRegenerateVerifiableDomainTokenInputBuilder toBuilder() =>
      new GRegenerateVerifiableDomainTokenInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRegenerateVerifiableDomainTokenInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRegenerateVerifiableDomainTokenInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GRegenerateVerifiableDomainTokenInputBuilder
    implements
        Builder<GRegenerateVerifiableDomainTokenInput,
            GRegenerateVerifiableDomainTokenInputBuilder> {
  _$GRegenerateVerifiableDomainTokenInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GRegenerateVerifiableDomainTokenInputBuilder();

  GRegenerateVerifiableDomainTokenInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRegenerateVerifiableDomainTokenInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRegenerateVerifiableDomainTokenInput;
  }

  @override
  void update(
      void Function(GRegenerateVerifiableDomainTokenInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRegenerateVerifiableDomainTokenInput build() {
    final _$result = _$v ??
        new _$GRegenerateVerifiableDomainTokenInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GRegenerateVerifiableDomainTokenInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GRejectDeploymentsInput extends GRejectDeploymentsInput {
  @override
  final String? clientMutationId;
  @override
  final String? comment;
  @override
  final BuiltList<String> environmentIds;
  @override
  final String workflowRunId;

  factory _$GRejectDeploymentsInput(
          [void Function(GRejectDeploymentsInputBuilder)? updates]) =>
      (new GRejectDeploymentsInputBuilder()..update(updates)).build();

  _$GRejectDeploymentsInput._(
      {this.clientMutationId,
      this.comment,
      required this.environmentIds,
      required this.workflowRunId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        environmentIds, 'GRejectDeploymentsInput', 'environmentIds');
    BuiltValueNullFieldError.checkNotNull(
        workflowRunId, 'GRejectDeploymentsInput', 'workflowRunId');
  }

  @override
  GRejectDeploymentsInput rebuild(
          void Function(GRejectDeploymentsInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRejectDeploymentsInputBuilder toBuilder() =>
      new GRejectDeploymentsInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRejectDeploymentsInput &&
        clientMutationId == other.clientMutationId &&
        comment == other.comment &&
        environmentIds == other.environmentIds &&
        workflowRunId == other.workflowRunId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), comment.hashCode),
            environmentIds.hashCode),
        workflowRunId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRejectDeploymentsInput')
          ..add('clientMutationId', clientMutationId)
          ..add('comment', comment)
          ..add('environmentIds', environmentIds)
          ..add('workflowRunId', workflowRunId))
        .toString();
  }
}

class GRejectDeploymentsInputBuilder
    implements
        Builder<GRejectDeploymentsInput, GRejectDeploymentsInputBuilder> {
  _$GRejectDeploymentsInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _comment;
  String? get comment => _$this._comment;
  set comment(String? comment) => _$this._comment = comment;

  ListBuilder<String>? _environmentIds;
  ListBuilder<String> get environmentIds =>
      _$this._environmentIds ??= new ListBuilder<String>();
  set environmentIds(ListBuilder<String>? environmentIds) =>
      _$this._environmentIds = environmentIds;

  String? _workflowRunId;
  String? get workflowRunId => _$this._workflowRunId;
  set workflowRunId(String? workflowRunId) =>
      _$this._workflowRunId = workflowRunId;

  GRejectDeploymentsInputBuilder();

  GRejectDeploymentsInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _comment = $v.comment;
      _environmentIds = $v.environmentIds.toBuilder();
      _workflowRunId = $v.workflowRunId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRejectDeploymentsInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRejectDeploymentsInput;
  }

  @override
  void update(void Function(GRejectDeploymentsInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRejectDeploymentsInput build() {
    _$GRejectDeploymentsInput _$result;
    try {
      _$result = _$v ??
          new _$GRejectDeploymentsInput._(
              clientMutationId: clientMutationId,
              comment: comment,
              environmentIds: environmentIds.build(),
              workflowRunId: BuiltValueNullFieldError.checkNotNull(
                  workflowRunId, 'GRejectDeploymentsInput', 'workflowRunId'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'environmentIds';
        environmentIds.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GRejectDeploymentsInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GReleaseOrder extends GReleaseOrder {
  @override
  final GOrderDirection direction;
  @override
  final GReleaseOrderField field;

  factory _$GReleaseOrder([void Function(GReleaseOrderBuilder)? updates]) =>
      (new GReleaseOrderBuilder()..update(updates)).build();

  _$GReleaseOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GReleaseOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GReleaseOrder', 'field');
  }

  @override
  GReleaseOrder rebuild(void Function(GReleaseOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GReleaseOrderBuilder toBuilder() => new GReleaseOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GReleaseOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GReleaseOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GReleaseOrderBuilder
    implements Builder<GReleaseOrder, GReleaseOrderBuilder> {
  _$GReleaseOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GReleaseOrderField? _field;
  GReleaseOrderField? get field => _$this._field;
  set field(GReleaseOrderField? field) => _$this._field = field;

  GReleaseOrderBuilder();

  GReleaseOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReleaseOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GReleaseOrder;
  }

  @override
  void update(void Function(GReleaseOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GReleaseOrder build() {
    final _$result = _$v ??
        new _$GReleaseOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GReleaseOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GReleaseOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveAssigneesFromAssignableInput
    extends GRemoveAssigneesFromAssignableInput {
  @override
  final String assignableId;
  @override
  final BuiltList<String> assigneeIds;
  @override
  final String? clientMutationId;

  factory _$GRemoveAssigneesFromAssignableInput(
          [void Function(GRemoveAssigneesFromAssignableInputBuilder)?
              updates]) =>
      (new GRemoveAssigneesFromAssignableInputBuilder()..update(updates))
          .build();

  _$GRemoveAssigneesFromAssignableInput._(
      {required this.assignableId,
      required this.assigneeIds,
      this.clientMutationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        assignableId, 'GRemoveAssigneesFromAssignableInput', 'assignableId');
    BuiltValueNullFieldError.checkNotNull(
        assigneeIds, 'GRemoveAssigneesFromAssignableInput', 'assigneeIds');
  }

  @override
  GRemoveAssigneesFromAssignableInput rebuild(
          void Function(GRemoveAssigneesFromAssignableInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveAssigneesFromAssignableInputBuilder toBuilder() =>
      new GRemoveAssigneesFromAssignableInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveAssigneesFromAssignableInput &&
        assignableId == other.assignableId &&
        assigneeIds == other.assigneeIds &&
        clientMutationId == other.clientMutationId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, assignableId.hashCode), assigneeIds.hashCode),
        clientMutationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveAssigneesFromAssignableInput')
          ..add('assignableId', assignableId)
          ..add('assigneeIds', assigneeIds)
          ..add('clientMutationId', clientMutationId))
        .toString();
  }
}

class GRemoveAssigneesFromAssignableInputBuilder
    implements
        Builder<GRemoveAssigneesFromAssignableInput,
            GRemoveAssigneesFromAssignableInputBuilder> {
  _$GRemoveAssigneesFromAssignableInput? _$v;

  String? _assignableId;
  String? get assignableId => _$this._assignableId;
  set assignableId(String? assignableId) => _$this._assignableId = assignableId;

  ListBuilder<String>? _assigneeIds;
  ListBuilder<String> get assigneeIds =>
      _$this._assigneeIds ??= new ListBuilder<String>();
  set assigneeIds(ListBuilder<String>? assigneeIds) =>
      _$this._assigneeIds = assigneeIds;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GRemoveAssigneesFromAssignableInputBuilder();

  GRemoveAssigneesFromAssignableInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _assignableId = $v.assignableId;
      _assigneeIds = $v.assigneeIds.toBuilder();
      _clientMutationId = $v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveAssigneesFromAssignableInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveAssigneesFromAssignableInput;
  }

  @override
  void update(
      void Function(GRemoveAssigneesFromAssignableInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveAssigneesFromAssignableInput build() {
    _$GRemoveAssigneesFromAssignableInput _$result;
    try {
      _$result = _$v ??
          new _$GRemoveAssigneesFromAssignableInput._(
              assignableId: BuiltValueNullFieldError.checkNotNull(assignableId,
                  'GRemoveAssigneesFromAssignableInput', 'assignableId'),
              assigneeIds: assigneeIds.build(),
              clientMutationId: clientMutationId);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'assigneeIds';
        assigneeIds.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GRemoveAssigneesFromAssignableInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveEnterpriseAdminInput extends GRemoveEnterpriseAdminInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final String login;

  factory _$GRemoveEnterpriseAdminInput(
          [void Function(GRemoveEnterpriseAdminInputBuilder)? updates]) =>
      (new GRemoveEnterpriseAdminInputBuilder()..update(updates)).build();

  _$GRemoveEnterpriseAdminInput._(
      {this.clientMutationId, required this.enterpriseId, required this.login})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GRemoveEnterpriseAdminInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        login, 'GRemoveEnterpriseAdminInput', 'login');
  }

  @override
  GRemoveEnterpriseAdminInput rebuild(
          void Function(GRemoveEnterpriseAdminInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveEnterpriseAdminInputBuilder toBuilder() =>
      new GRemoveEnterpriseAdminInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveEnterpriseAdminInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        login == other.login;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        login.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveEnterpriseAdminInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('login', login))
        .toString();
  }
}

class GRemoveEnterpriseAdminInputBuilder
    implements
        Builder<GRemoveEnterpriseAdminInput,
            GRemoveEnterpriseAdminInputBuilder> {
  _$GRemoveEnterpriseAdminInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _login;
  String? get login => _$this._login;
  set login(String? login) => _$this._login = login;

  GRemoveEnterpriseAdminInputBuilder();

  GRemoveEnterpriseAdminInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _login = $v.login;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveEnterpriseAdminInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveEnterpriseAdminInput;
  }

  @override
  void update(void Function(GRemoveEnterpriseAdminInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveEnterpriseAdminInput build() {
    final _$result = _$v ??
        new _$GRemoveEnterpriseAdminInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId, 'GRemoveEnterpriseAdminInput', 'enterpriseId'),
            login: BuiltValueNullFieldError.checkNotNull(
                login, 'GRemoveEnterpriseAdminInput', 'login'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveEnterpriseIdentityProviderInput
    extends GRemoveEnterpriseIdentityProviderInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;

  factory _$GRemoveEnterpriseIdentityProviderInput(
          [void Function(GRemoveEnterpriseIdentityProviderInputBuilder)?
              updates]) =>
      (new GRemoveEnterpriseIdentityProviderInputBuilder()..update(updates))
          .build();

  _$GRemoveEnterpriseIdentityProviderInput._(
      {this.clientMutationId, required this.enterpriseId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GRemoveEnterpriseIdentityProviderInput', 'enterpriseId');
  }

  @override
  GRemoveEnterpriseIdentityProviderInput rebuild(
          void Function(GRemoveEnterpriseIdentityProviderInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveEnterpriseIdentityProviderInputBuilder toBuilder() =>
      new GRemoveEnterpriseIdentityProviderInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveEnterpriseIdentityProviderInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GRemoveEnterpriseIdentityProviderInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId))
        .toString();
  }
}

class GRemoveEnterpriseIdentityProviderInputBuilder
    implements
        Builder<GRemoveEnterpriseIdentityProviderInput,
            GRemoveEnterpriseIdentityProviderInputBuilder> {
  _$GRemoveEnterpriseIdentityProviderInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GRemoveEnterpriseIdentityProviderInputBuilder();

  GRemoveEnterpriseIdentityProviderInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveEnterpriseIdentityProviderInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveEnterpriseIdentityProviderInput;
  }

  @override
  void update(
      void Function(GRemoveEnterpriseIdentityProviderInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveEnterpriseIdentityProviderInput build() {
    final _$result = _$v ??
        new _$GRemoveEnterpriseIdentityProviderInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                'GRemoveEnterpriseIdentityProviderInput', 'enterpriseId'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveEnterpriseOrganizationInput
    extends GRemoveEnterpriseOrganizationInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final String organizationId;

  factory _$GRemoveEnterpriseOrganizationInput(
          [void Function(GRemoveEnterpriseOrganizationInputBuilder)?
              updates]) =>
      (new GRemoveEnterpriseOrganizationInputBuilder()..update(updates))
          .build();

  _$GRemoveEnterpriseOrganizationInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.organizationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GRemoveEnterpriseOrganizationInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        organizationId, 'GRemoveEnterpriseOrganizationInput', 'organizationId');
  }

  @override
  GRemoveEnterpriseOrganizationInput rebuild(
          void Function(GRemoveEnterpriseOrganizationInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveEnterpriseOrganizationInputBuilder toBuilder() =>
      new GRemoveEnterpriseOrganizationInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveEnterpriseOrganizationInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        organizationId == other.organizationId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        organizationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveEnterpriseOrganizationInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('organizationId', organizationId))
        .toString();
  }
}

class GRemoveEnterpriseOrganizationInputBuilder
    implements
        Builder<GRemoveEnterpriseOrganizationInput,
            GRemoveEnterpriseOrganizationInputBuilder> {
  _$GRemoveEnterpriseOrganizationInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _organizationId;
  String? get organizationId => _$this._organizationId;
  set organizationId(String? organizationId) =>
      _$this._organizationId = organizationId;

  GRemoveEnterpriseOrganizationInputBuilder();

  GRemoveEnterpriseOrganizationInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _organizationId = $v.organizationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveEnterpriseOrganizationInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveEnterpriseOrganizationInput;
  }

  @override
  void update(
      void Function(GRemoveEnterpriseOrganizationInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveEnterpriseOrganizationInput build() {
    final _$result = _$v ??
        new _$GRemoveEnterpriseOrganizationInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                'GRemoveEnterpriseOrganizationInput', 'enterpriseId'),
            organizationId: BuiltValueNullFieldError.checkNotNull(
                organizationId,
                'GRemoveEnterpriseOrganizationInput',
                'organizationId'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveEnterpriseSupportEntitlementInput
    extends GRemoveEnterpriseSupportEntitlementInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final String login;

  factory _$GRemoveEnterpriseSupportEntitlementInput(
          [void Function(GRemoveEnterpriseSupportEntitlementInputBuilder)?
              updates]) =>
      (new GRemoveEnterpriseSupportEntitlementInputBuilder()..update(updates))
          .build();

  _$GRemoveEnterpriseSupportEntitlementInput._(
      {this.clientMutationId, required this.enterpriseId, required this.login})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(enterpriseId,
        'GRemoveEnterpriseSupportEntitlementInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        login, 'GRemoveEnterpriseSupportEntitlementInput', 'login');
  }

  @override
  GRemoveEnterpriseSupportEntitlementInput rebuild(
          void Function(GRemoveEnterpriseSupportEntitlementInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveEnterpriseSupportEntitlementInputBuilder toBuilder() =>
      new GRemoveEnterpriseSupportEntitlementInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveEnterpriseSupportEntitlementInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        login == other.login;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        login.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GRemoveEnterpriseSupportEntitlementInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('login', login))
        .toString();
  }
}

class GRemoveEnterpriseSupportEntitlementInputBuilder
    implements
        Builder<GRemoveEnterpriseSupportEntitlementInput,
            GRemoveEnterpriseSupportEntitlementInputBuilder> {
  _$GRemoveEnterpriseSupportEntitlementInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _login;
  String? get login => _$this._login;
  set login(String? login) => _$this._login = login;

  GRemoveEnterpriseSupportEntitlementInputBuilder();

  GRemoveEnterpriseSupportEntitlementInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _login = $v.login;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveEnterpriseSupportEntitlementInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveEnterpriseSupportEntitlementInput;
  }

  @override
  void update(
      void Function(GRemoveEnterpriseSupportEntitlementInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveEnterpriseSupportEntitlementInput build() {
    final _$result = _$v ??
        new _$GRemoveEnterpriseSupportEntitlementInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                'GRemoveEnterpriseSupportEntitlementInput', 'enterpriseId'),
            login: BuiltValueNullFieldError.checkNotNull(
                login, 'GRemoveEnterpriseSupportEntitlementInput', 'login'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveLabelsFromLabelableInput
    extends GRemoveLabelsFromLabelableInput {
  @override
  final String? clientMutationId;
  @override
  final BuiltList<String> labelIds;
  @override
  final String labelableId;

  factory _$GRemoveLabelsFromLabelableInput(
          [void Function(GRemoveLabelsFromLabelableInputBuilder)? updates]) =>
      (new GRemoveLabelsFromLabelableInputBuilder()..update(updates)).build();

  _$GRemoveLabelsFromLabelableInput._(
      {this.clientMutationId,
      required this.labelIds,
      required this.labelableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        labelIds, 'GRemoveLabelsFromLabelableInput', 'labelIds');
    BuiltValueNullFieldError.checkNotNull(
        labelableId, 'GRemoveLabelsFromLabelableInput', 'labelableId');
  }

  @override
  GRemoveLabelsFromLabelableInput rebuild(
          void Function(GRemoveLabelsFromLabelableInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveLabelsFromLabelableInputBuilder toBuilder() =>
      new GRemoveLabelsFromLabelableInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveLabelsFromLabelableInput &&
        clientMutationId == other.clientMutationId &&
        labelIds == other.labelIds &&
        labelableId == other.labelableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), labelIds.hashCode),
        labelableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveLabelsFromLabelableInput')
          ..add('clientMutationId', clientMutationId)
          ..add('labelIds', labelIds)
          ..add('labelableId', labelableId))
        .toString();
  }
}

class GRemoveLabelsFromLabelableInputBuilder
    implements
        Builder<GRemoveLabelsFromLabelableInput,
            GRemoveLabelsFromLabelableInputBuilder> {
  _$GRemoveLabelsFromLabelableInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  ListBuilder<String>? _labelIds;
  ListBuilder<String> get labelIds =>
      _$this._labelIds ??= new ListBuilder<String>();
  set labelIds(ListBuilder<String>? labelIds) => _$this._labelIds = labelIds;

  String? _labelableId;
  String? get labelableId => _$this._labelableId;
  set labelableId(String? labelableId) => _$this._labelableId = labelableId;

  GRemoveLabelsFromLabelableInputBuilder();

  GRemoveLabelsFromLabelableInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _labelIds = $v.labelIds.toBuilder();
      _labelableId = $v.labelableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveLabelsFromLabelableInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveLabelsFromLabelableInput;
  }

  @override
  void update(void Function(GRemoveLabelsFromLabelableInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveLabelsFromLabelableInput build() {
    _$GRemoveLabelsFromLabelableInput _$result;
    try {
      _$result = _$v ??
          new _$GRemoveLabelsFromLabelableInput._(
              clientMutationId: clientMutationId,
              labelIds: labelIds.build(),
              labelableId: BuiltValueNullFieldError.checkNotNull(labelableId,
                  'GRemoveLabelsFromLabelableInput', 'labelableId'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'labelIds';
        labelIds.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GRemoveLabelsFromLabelableInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveOutsideCollaboratorInput
    extends GRemoveOutsideCollaboratorInput {
  @override
  final String? clientMutationId;
  @override
  final String organizationId;
  @override
  final String userId;

  factory _$GRemoveOutsideCollaboratorInput(
          [void Function(GRemoveOutsideCollaboratorInputBuilder)? updates]) =>
      (new GRemoveOutsideCollaboratorInputBuilder()..update(updates)).build();

  _$GRemoveOutsideCollaboratorInput._(
      {this.clientMutationId,
      required this.organizationId,
      required this.userId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        organizationId, 'GRemoveOutsideCollaboratorInput', 'organizationId');
    BuiltValueNullFieldError.checkNotNull(
        userId, 'GRemoveOutsideCollaboratorInput', 'userId');
  }

  @override
  GRemoveOutsideCollaboratorInput rebuild(
          void Function(GRemoveOutsideCollaboratorInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveOutsideCollaboratorInputBuilder toBuilder() =>
      new GRemoveOutsideCollaboratorInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveOutsideCollaboratorInput &&
        clientMutationId == other.clientMutationId &&
        organizationId == other.organizationId &&
        userId == other.userId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), organizationId.hashCode),
        userId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveOutsideCollaboratorInput')
          ..add('clientMutationId', clientMutationId)
          ..add('organizationId', organizationId)
          ..add('userId', userId))
        .toString();
  }
}

class GRemoveOutsideCollaboratorInputBuilder
    implements
        Builder<GRemoveOutsideCollaboratorInput,
            GRemoveOutsideCollaboratorInputBuilder> {
  _$GRemoveOutsideCollaboratorInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _organizationId;
  String? get organizationId => _$this._organizationId;
  set organizationId(String? organizationId) =>
      _$this._organizationId = organizationId;

  String? _userId;
  String? get userId => _$this._userId;
  set userId(String? userId) => _$this._userId = userId;

  GRemoveOutsideCollaboratorInputBuilder();

  GRemoveOutsideCollaboratorInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _organizationId = $v.organizationId;
      _userId = $v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveOutsideCollaboratorInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveOutsideCollaboratorInput;
  }

  @override
  void update(void Function(GRemoveOutsideCollaboratorInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveOutsideCollaboratorInput build() {
    final _$result = _$v ??
        new _$GRemoveOutsideCollaboratorInput._(
            clientMutationId: clientMutationId,
            organizationId: BuiltValueNullFieldError.checkNotNull(
                organizationId,
                'GRemoveOutsideCollaboratorInput',
                'organizationId'),
            userId: BuiltValueNullFieldError.checkNotNull(
                userId, 'GRemoveOutsideCollaboratorInput', 'userId'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveReactionInput extends GRemoveReactionInput {
  @override
  final String? clientMutationId;
  @override
  final GReactionContent content;
  @override
  final String subjectId;

  factory _$GRemoveReactionInput(
          [void Function(GRemoveReactionInputBuilder)? updates]) =>
      (new GRemoveReactionInputBuilder()..update(updates)).build();

  _$GRemoveReactionInput._(
      {this.clientMutationId, required this.content, required this.subjectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        content, 'GRemoveReactionInput', 'content');
    BuiltValueNullFieldError.checkNotNull(
        subjectId, 'GRemoveReactionInput', 'subjectId');
  }

  @override
  GRemoveReactionInput rebuild(
          void Function(GRemoveReactionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveReactionInputBuilder toBuilder() =>
      new GRemoveReactionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveReactionInput &&
        clientMutationId == other.clientMutationId &&
        content == other.content &&
        subjectId == other.subjectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), content.hashCode),
        subjectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveReactionInput')
          ..add('clientMutationId', clientMutationId)
          ..add('content', content)
          ..add('subjectId', subjectId))
        .toString();
  }
}

class GRemoveReactionInputBuilder
    implements Builder<GRemoveReactionInput, GRemoveReactionInputBuilder> {
  _$GRemoveReactionInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GReactionContent? _content;
  GReactionContent? get content => _$this._content;
  set content(GReactionContent? content) => _$this._content = content;

  String? _subjectId;
  String? get subjectId => _$this._subjectId;
  set subjectId(String? subjectId) => _$this._subjectId = subjectId;

  GRemoveReactionInputBuilder();

  GRemoveReactionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _content = $v.content;
      _subjectId = $v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveReactionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveReactionInput;
  }

  @override
  void update(void Function(GRemoveReactionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveReactionInput build() {
    final _$result = _$v ??
        new _$GRemoveReactionInput._(
            clientMutationId: clientMutationId,
            content: BuiltValueNullFieldError.checkNotNull(
                content, 'GRemoveReactionInput', 'content'),
            subjectId: BuiltValueNullFieldError.checkNotNull(
                subjectId, 'GRemoveReactionInput', 'subjectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveStarInput extends GRemoveStarInput {
  @override
  final String? clientMutationId;
  @override
  final String starrableId;

  factory _$GRemoveStarInput(
          [void Function(GRemoveStarInputBuilder)? updates]) =>
      (new GRemoveStarInputBuilder()..update(updates)).build();

  _$GRemoveStarInput._({this.clientMutationId, required this.starrableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        starrableId, 'GRemoveStarInput', 'starrableId');
  }

  @override
  GRemoveStarInput rebuild(void Function(GRemoveStarInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveStarInputBuilder toBuilder() =>
      new GRemoveStarInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveStarInput &&
        clientMutationId == other.clientMutationId &&
        starrableId == other.starrableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), starrableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveStarInput')
          ..add('clientMutationId', clientMutationId)
          ..add('starrableId', starrableId))
        .toString();
  }
}

class GRemoveStarInputBuilder
    implements Builder<GRemoveStarInput, GRemoveStarInputBuilder> {
  _$GRemoveStarInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _starrableId;
  String? get starrableId => _$this._starrableId;
  set starrableId(String? starrableId) => _$this._starrableId = starrableId;

  GRemoveStarInputBuilder();

  GRemoveStarInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _starrableId = $v.starrableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveStarInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveStarInput;
  }

  @override
  void update(void Function(GRemoveStarInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveStarInput build() {
    final _$result = _$v ??
        new _$GRemoveStarInput._(
            clientMutationId: clientMutationId,
            starrableId: BuiltValueNullFieldError.checkNotNull(
                starrableId, 'GRemoveStarInput', 'starrableId'));
    replace(_$result);
    return _$result;
  }
}

class _$GRemoveUpvoteInput extends GRemoveUpvoteInput {
  @override
  final String? clientMutationId;
  @override
  final String subjectId;

  factory _$GRemoveUpvoteInput(
          [void Function(GRemoveUpvoteInputBuilder)? updates]) =>
      (new GRemoveUpvoteInputBuilder()..update(updates)).build();

  _$GRemoveUpvoteInput._({this.clientMutationId, required this.subjectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        subjectId, 'GRemoveUpvoteInput', 'subjectId');
  }

  @override
  GRemoveUpvoteInput rebuild(
          void Function(GRemoveUpvoteInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRemoveUpvoteInputBuilder toBuilder() =>
      new GRemoveUpvoteInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRemoveUpvoteInput &&
        clientMutationId == other.clientMutationId &&
        subjectId == other.subjectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), subjectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRemoveUpvoteInput')
          ..add('clientMutationId', clientMutationId)
          ..add('subjectId', subjectId))
        .toString();
  }
}

class GRemoveUpvoteInputBuilder
    implements Builder<GRemoveUpvoteInput, GRemoveUpvoteInputBuilder> {
  _$GRemoveUpvoteInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _subjectId;
  String? get subjectId => _$this._subjectId;
  set subjectId(String? subjectId) => _$this._subjectId = subjectId;

  GRemoveUpvoteInputBuilder();

  GRemoveUpvoteInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _subjectId = $v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveUpvoteInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRemoveUpvoteInput;
  }

  @override
  void update(void Function(GRemoveUpvoteInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRemoveUpvoteInput build() {
    final _$result = _$v ??
        new _$GRemoveUpvoteInput._(
            clientMutationId: clientMutationId,
            subjectId: BuiltValueNullFieldError.checkNotNull(
                subjectId, 'GRemoveUpvoteInput', 'subjectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GReopenIssueInput extends GReopenIssueInput {
  @override
  final String? clientMutationId;
  @override
  final String issueId;

  factory _$GReopenIssueInput(
          [void Function(GReopenIssueInputBuilder)? updates]) =>
      (new GReopenIssueInputBuilder()..update(updates)).build();

  _$GReopenIssueInput._({this.clientMutationId, required this.issueId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        issueId, 'GReopenIssueInput', 'issueId');
  }

  @override
  GReopenIssueInput rebuild(void Function(GReopenIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GReopenIssueInputBuilder toBuilder() =>
      new GReopenIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GReopenIssueInput &&
        clientMutationId == other.clientMutationId &&
        issueId == other.issueId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), issueId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GReopenIssueInput')
          ..add('clientMutationId', clientMutationId)
          ..add('issueId', issueId))
        .toString();
  }
}

class GReopenIssueInputBuilder
    implements Builder<GReopenIssueInput, GReopenIssueInputBuilder> {
  _$GReopenIssueInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _issueId;
  String? get issueId => _$this._issueId;
  set issueId(String? issueId) => _$this._issueId = issueId;

  GReopenIssueInputBuilder();

  GReopenIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _issueId = $v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReopenIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GReopenIssueInput;
  }

  @override
  void update(void Function(GReopenIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GReopenIssueInput build() {
    final _$result = _$v ??
        new _$GReopenIssueInput._(
            clientMutationId: clientMutationId,
            issueId: BuiltValueNullFieldError.checkNotNull(
                issueId, 'GReopenIssueInput', 'issueId'));
    replace(_$result);
    return _$result;
  }
}

class _$GReopenPullRequestInput extends GReopenPullRequestInput {
  @override
  final String? clientMutationId;
  @override
  final String pullRequestId;

  factory _$GReopenPullRequestInput(
          [void Function(GReopenPullRequestInputBuilder)? updates]) =>
      (new GReopenPullRequestInputBuilder()..update(updates)).build();

  _$GReopenPullRequestInput._(
      {this.clientMutationId, required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GReopenPullRequestInput', 'pullRequestId');
  }

  @override
  GReopenPullRequestInput rebuild(
          void Function(GReopenPullRequestInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GReopenPullRequestInputBuilder toBuilder() =>
      new GReopenPullRequestInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GReopenPullRequestInput &&
        clientMutationId == other.clientMutationId &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GReopenPullRequestInput')
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GReopenPullRequestInputBuilder
    implements
        Builder<GReopenPullRequestInput, GReopenPullRequestInputBuilder> {
  _$GReopenPullRequestInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GReopenPullRequestInputBuilder();

  GReopenPullRequestInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReopenPullRequestInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GReopenPullRequestInput;
  }

  @override
  void update(void Function(GReopenPullRequestInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GReopenPullRequestInput build() {
    final _$result = _$v ??
        new _$GReopenPullRequestInput._(
            clientMutationId: clientMutationId,
            pullRequestId: BuiltValueNullFieldError.checkNotNull(
                pullRequestId, 'GReopenPullRequestInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GRepositoryInvitationOrder extends GRepositoryInvitationOrder {
  @override
  final GOrderDirection direction;
  @override
  final GRepositoryInvitationOrderField field;

  factory _$GRepositoryInvitationOrder(
          [void Function(GRepositoryInvitationOrderBuilder)? updates]) =>
      (new GRepositoryInvitationOrderBuilder()..update(updates)).build();

  _$GRepositoryInvitationOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GRepositoryInvitationOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GRepositoryInvitationOrder', 'field');
  }

  @override
  GRepositoryInvitationOrder rebuild(
          void Function(GRepositoryInvitationOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRepositoryInvitationOrderBuilder toBuilder() =>
      new GRepositoryInvitationOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRepositoryInvitationOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRepositoryInvitationOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GRepositoryInvitationOrderBuilder
    implements
        Builder<GRepositoryInvitationOrder, GRepositoryInvitationOrderBuilder> {
  _$GRepositoryInvitationOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GRepositoryInvitationOrderField? _field;
  GRepositoryInvitationOrderField? get field => _$this._field;
  set field(GRepositoryInvitationOrderField? field) => _$this._field = field;

  GRepositoryInvitationOrderBuilder();

  GRepositoryInvitationOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRepositoryInvitationOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRepositoryInvitationOrder;
  }

  @override
  void update(void Function(GRepositoryInvitationOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRepositoryInvitationOrder build() {
    final _$result = _$v ??
        new _$GRepositoryInvitationOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GRepositoryInvitationOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GRepositoryInvitationOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GRepositoryOrder extends GRepositoryOrder {
  @override
  final GOrderDirection direction;
  @override
  final GRepositoryOrderField field;

  factory _$GRepositoryOrder(
          [void Function(GRepositoryOrderBuilder)? updates]) =>
      (new GRepositoryOrderBuilder()..update(updates)).build();

  _$GRepositoryOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GRepositoryOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GRepositoryOrder', 'field');
  }

  @override
  GRepositoryOrder rebuild(void Function(GRepositoryOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRepositoryOrderBuilder toBuilder() =>
      new GRepositoryOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRepositoryOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRepositoryOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GRepositoryOrderBuilder
    implements Builder<GRepositoryOrder, GRepositoryOrderBuilder> {
  _$GRepositoryOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GRepositoryOrderField? _field;
  GRepositoryOrderField? get field => _$this._field;
  set field(GRepositoryOrderField? field) => _$this._field = field;

  GRepositoryOrderBuilder();

  GRepositoryOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRepositoryOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRepositoryOrder;
  }

  @override
  void update(void Function(GRepositoryOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRepositoryOrder build() {
    final _$result = _$v ??
        new _$GRepositoryOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GRepositoryOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GRepositoryOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GRequestReviewsInput extends GRequestReviewsInput {
  @override
  final String? clientMutationId;
  @override
  final String pullRequestId;
  @override
  final BuiltList<String>? teamIds;
  @override
  final bool? union;
  @override
  final BuiltList<String>? userIds;

  factory _$GRequestReviewsInput(
          [void Function(GRequestReviewsInputBuilder)? updates]) =>
      (new GRequestReviewsInputBuilder()..update(updates)).build();

  _$GRequestReviewsInput._(
      {this.clientMutationId,
      required this.pullRequestId,
      this.teamIds,
      this.union,
      this.userIds})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GRequestReviewsInput', 'pullRequestId');
  }

  @override
  GRequestReviewsInput rebuild(
          void Function(GRequestReviewsInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRequestReviewsInputBuilder toBuilder() =>
      new GRequestReviewsInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRequestReviewsInput &&
        clientMutationId == other.clientMutationId &&
        pullRequestId == other.pullRequestId &&
        teamIds == other.teamIds &&
        union == other.union &&
        userIds == other.userIds;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, clientMutationId.hashCode), pullRequestId.hashCode),
                teamIds.hashCode),
            union.hashCode),
        userIds.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRequestReviewsInput')
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestId', pullRequestId)
          ..add('teamIds', teamIds)
          ..add('union', union)
          ..add('userIds', userIds))
        .toString();
  }
}

class GRequestReviewsInputBuilder
    implements Builder<GRequestReviewsInput, GRequestReviewsInputBuilder> {
  _$GRequestReviewsInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  ListBuilder<String>? _teamIds;
  ListBuilder<String> get teamIds =>
      _$this._teamIds ??= new ListBuilder<String>();
  set teamIds(ListBuilder<String>? teamIds) => _$this._teamIds = teamIds;

  bool? _union;
  bool? get union => _$this._union;
  set union(bool? union) => _$this._union = union;

  ListBuilder<String>? _userIds;
  ListBuilder<String> get userIds =>
      _$this._userIds ??= new ListBuilder<String>();
  set userIds(ListBuilder<String>? userIds) => _$this._userIds = userIds;

  GRequestReviewsInputBuilder();

  GRequestReviewsInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _pullRequestId = $v.pullRequestId;
      _teamIds = $v.teamIds?.toBuilder();
      _union = $v.union;
      _userIds = $v.userIds?.toBuilder();
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRequestReviewsInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRequestReviewsInput;
  }

  @override
  void update(void Function(GRequestReviewsInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRequestReviewsInput build() {
    _$GRequestReviewsInput _$result;
    try {
      _$result = _$v ??
          new _$GRequestReviewsInput._(
              clientMutationId: clientMutationId,
              pullRequestId: BuiltValueNullFieldError.checkNotNull(
                  pullRequestId, 'GRequestReviewsInput', 'pullRequestId'),
              teamIds: _teamIds?.build(),
              union: union,
              userIds: _userIds?.build());
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'teamIds';
        _teamIds?.build();

        _$failedField = 'userIds';
        _userIds?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GRequestReviewsInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GRerequestCheckSuiteInput extends GRerequestCheckSuiteInput {
  @override
  final String checkSuiteId;
  @override
  final String? clientMutationId;
  @override
  final String repositoryId;

  factory _$GRerequestCheckSuiteInput(
          [void Function(GRerequestCheckSuiteInputBuilder)? updates]) =>
      (new GRerequestCheckSuiteInputBuilder()..update(updates)).build();

  _$GRerequestCheckSuiteInput._(
      {required this.checkSuiteId,
      this.clientMutationId,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        checkSuiteId, 'GRerequestCheckSuiteInput', 'checkSuiteId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GRerequestCheckSuiteInput', 'repositoryId');
  }

  @override
  GRerequestCheckSuiteInput rebuild(
          void Function(GRerequestCheckSuiteInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GRerequestCheckSuiteInputBuilder toBuilder() =>
      new GRerequestCheckSuiteInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GRerequestCheckSuiteInput &&
        checkSuiteId == other.checkSuiteId &&
        clientMutationId == other.clientMutationId &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, checkSuiteId.hashCode), clientMutationId.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GRerequestCheckSuiteInput')
          ..add('checkSuiteId', checkSuiteId)
          ..add('clientMutationId', clientMutationId)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GRerequestCheckSuiteInputBuilder
    implements
        Builder<GRerequestCheckSuiteInput, GRerequestCheckSuiteInputBuilder> {
  _$GRerequestCheckSuiteInput? _$v;

  String? _checkSuiteId;
  String? get checkSuiteId => _$this._checkSuiteId;
  set checkSuiteId(String? checkSuiteId) => _$this._checkSuiteId = checkSuiteId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GRerequestCheckSuiteInputBuilder();

  GRerequestCheckSuiteInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _checkSuiteId = $v.checkSuiteId;
      _clientMutationId = $v.clientMutationId;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRerequestCheckSuiteInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GRerequestCheckSuiteInput;
  }

  @override
  void update(void Function(GRerequestCheckSuiteInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GRerequestCheckSuiteInput build() {
    final _$result = _$v ??
        new _$GRerequestCheckSuiteInput._(
            checkSuiteId: BuiltValueNullFieldError.checkNotNull(
                checkSuiteId, 'GRerequestCheckSuiteInput', 'checkSuiteId'),
            clientMutationId: clientMutationId,
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GRerequestCheckSuiteInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GResolveReviewThreadInput extends GResolveReviewThreadInput {
  @override
  final String? clientMutationId;
  @override
  final String threadId;

  factory _$GResolveReviewThreadInput(
          [void Function(GResolveReviewThreadInputBuilder)? updates]) =>
      (new GResolveReviewThreadInputBuilder()..update(updates)).build();

  _$GResolveReviewThreadInput._({this.clientMutationId, required this.threadId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        threadId, 'GResolveReviewThreadInput', 'threadId');
  }

  @override
  GResolveReviewThreadInput rebuild(
          void Function(GResolveReviewThreadInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GResolveReviewThreadInputBuilder toBuilder() =>
      new GResolveReviewThreadInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GResolveReviewThreadInput &&
        clientMutationId == other.clientMutationId &&
        threadId == other.threadId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), threadId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GResolveReviewThreadInput')
          ..add('clientMutationId', clientMutationId)
          ..add('threadId', threadId))
        .toString();
  }
}

class GResolveReviewThreadInputBuilder
    implements
        Builder<GResolveReviewThreadInput, GResolveReviewThreadInputBuilder> {
  _$GResolveReviewThreadInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _threadId;
  String? get threadId => _$this._threadId;
  set threadId(String? threadId) => _$this._threadId = threadId;

  GResolveReviewThreadInputBuilder();

  GResolveReviewThreadInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _threadId = $v.threadId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GResolveReviewThreadInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GResolveReviewThreadInput;
  }

  @override
  void update(void Function(GResolveReviewThreadInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GResolveReviewThreadInput build() {
    final _$result = _$v ??
        new _$GResolveReviewThreadInput._(
            clientMutationId: clientMutationId,
            threadId: BuiltValueNullFieldError.checkNotNull(
                threadId, 'GResolveReviewThreadInput', 'threadId'));
    replace(_$result);
    return _$result;
  }
}

class _$GSavedReplyOrder extends GSavedReplyOrder {
  @override
  final GOrderDirection direction;
  @override
  final GSavedReplyOrderField field;

  factory _$GSavedReplyOrder(
          [void Function(GSavedReplyOrderBuilder)? updates]) =>
      (new GSavedReplyOrderBuilder()..update(updates)).build();

  _$GSavedReplyOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GSavedReplyOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GSavedReplyOrder', 'field');
  }

  @override
  GSavedReplyOrder rebuild(void Function(GSavedReplyOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSavedReplyOrderBuilder toBuilder() =>
      new GSavedReplyOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSavedReplyOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSavedReplyOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GSavedReplyOrderBuilder
    implements Builder<GSavedReplyOrder, GSavedReplyOrderBuilder> {
  _$GSavedReplyOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GSavedReplyOrderField? _field;
  GSavedReplyOrderField? get field => _$this._field;
  set field(GSavedReplyOrderField? field) => _$this._field = field;

  GSavedReplyOrderBuilder();

  GSavedReplyOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSavedReplyOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSavedReplyOrder;
  }

  @override
  void update(void Function(GSavedReplyOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSavedReplyOrder build() {
    final _$result = _$v ??
        new _$GSavedReplyOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GSavedReplyOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GSavedReplyOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GSecurityAdvisoryIdentifierFilter
    extends GSecurityAdvisoryIdentifierFilter {
  @override
  final GSecurityAdvisoryIdentifierType type;
  @override
  final String value;

  factory _$GSecurityAdvisoryIdentifierFilter(
          [void Function(GSecurityAdvisoryIdentifierFilterBuilder)? updates]) =>
      (new GSecurityAdvisoryIdentifierFilterBuilder()..update(updates)).build();

  _$GSecurityAdvisoryIdentifierFilter._(
      {required this.type, required this.value})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        type, 'GSecurityAdvisoryIdentifierFilter', 'type');
    BuiltValueNullFieldError.checkNotNull(
        value, 'GSecurityAdvisoryIdentifierFilter', 'value');
  }

  @override
  GSecurityAdvisoryIdentifierFilter rebuild(
          void Function(GSecurityAdvisoryIdentifierFilterBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSecurityAdvisoryIdentifierFilterBuilder toBuilder() =>
      new GSecurityAdvisoryIdentifierFilterBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSecurityAdvisoryIdentifierFilter &&
        type == other.type &&
        value == other.value;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, type.hashCode), value.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSecurityAdvisoryIdentifierFilter')
          ..add('type', type)
          ..add('value', value))
        .toString();
  }
}

class GSecurityAdvisoryIdentifierFilterBuilder
    implements
        Builder<GSecurityAdvisoryIdentifierFilter,
            GSecurityAdvisoryIdentifierFilterBuilder> {
  _$GSecurityAdvisoryIdentifierFilter? _$v;

  GSecurityAdvisoryIdentifierType? _type;
  GSecurityAdvisoryIdentifierType? get type => _$this._type;
  set type(GSecurityAdvisoryIdentifierType? type) => _$this._type = type;

  String? _value;
  String? get value => _$this._value;
  set value(String? value) => _$this._value = value;

  GSecurityAdvisoryIdentifierFilterBuilder();

  GSecurityAdvisoryIdentifierFilterBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _type = $v.type;
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSecurityAdvisoryIdentifierFilter other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSecurityAdvisoryIdentifierFilter;
  }

  @override
  void update(
      void Function(GSecurityAdvisoryIdentifierFilterBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSecurityAdvisoryIdentifierFilter build() {
    final _$result = _$v ??
        new _$GSecurityAdvisoryIdentifierFilter._(
            type: BuiltValueNullFieldError.checkNotNull(
                type, 'GSecurityAdvisoryIdentifierFilter', 'type'),
            value: BuiltValueNullFieldError.checkNotNull(
                value, 'GSecurityAdvisoryIdentifierFilter', 'value'));
    replace(_$result);
    return _$result;
  }
}

class _$GSecurityAdvisoryOrder extends GSecurityAdvisoryOrder {
  @override
  final GOrderDirection direction;
  @override
  final GSecurityAdvisoryOrderField field;

  factory _$GSecurityAdvisoryOrder(
          [void Function(GSecurityAdvisoryOrderBuilder)? updates]) =>
      (new GSecurityAdvisoryOrderBuilder()..update(updates)).build();

  _$GSecurityAdvisoryOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GSecurityAdvisoryOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GSecurityAdvisoryOrder', 'field');
  }

  @override
  GSecurityAdvisoryOrder rebuild(
          void Function(GSecurityAdvisoryOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSecurityAdvisoryOrderBuilder toBuilder() =>
      new GSecurityAdvisoryOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSecurityAdvisoryOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSecurityAdvisoryOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GSecurityAdvisoryOrderBuilder
    implements Builder<GSecurityAdvisoryOrder, GSecurityAdvisoryOrderBuilder> {
  _$GSecurityAdvisoryOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GSecurityAdvisoryOrderField? _field;
  GSecurityAdvisoryOrderField? get field => _$this._field;
  set field(GSecurityAdvisoryOrderField? field) => _$this._field = field;

  GSecurityAdvisoryOrderBuilder();

  GSecurityAdvisoryOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSecurityAdvisoryOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSecurityAdvisoryOrder;
  }

  @override
  void update(void Function(GSecurityAdvisoryOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSecurityAdvisoryOrder build() {
    final _$result = _$v ??
        new _$GSecurityAdvisoryOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GSecurityAdvisoryOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GSecurityAdvisoryOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GSecurityVulnerabilityOrder extends GSecurityVulnerabilityOrder {
  @override
  final GOrderDirection direction;
  @override
  final GSecurityVulnerabilityOrderField field;

  factory _$GSecurityVulnerabilityOrder(
          [void Function(GSecurityVulnerabilityOrderBuilder)? updates]) =>
      (new GSecurityVulnerabilityOrderBuilder()..update(updates)).build();

  _$GSecurityVulnerabilityOrder._(
      {required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GSecurityVulnerabilityOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GSecurityVulnerabilityOrder', 'field');
  }

  @override
  GSecurityVulnerabilityOrder rebuild(
          void Function(GSecurityVulnerabilityOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSecurityVulnerabilityOrderBuilder toBuilder() =>
      new GSecurityVulnerabilityOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSecurityVulnerabilityOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSecurityVulnerabilityOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GSecurityVulnerabilityOrderBuilder
    implements
        Builder<GSecurityVulnerabilityOrder,
            GSecurityVulnerabilityOrderBuilder> {
  _$GSecurityVulnerabilityOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GSecurityVulnerabilityOrderField? _field;
  GSecurityVulnerabilityOrderField? get field => _$this._field;
  set field(GSecurityVulnerabilityOrderField? field) => _$this._field = field;

  GSecurityVulnerabilityOrderBuilder();

  GSecurityVulnerabilityOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSecurityVulnerabilityOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSecurityVulnerabilityOrder;
  }

  @override
  void update(void Function(GSecurityVulnerabilityOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSecurityVulnerabilityOrder build() {
    final _$result = _$v ??
        new _$GSecurityVulnerabilityOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GSecurityVulnerabilityOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GSecurityVulnerabilityOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GSetEnterpriseIdentityProviderInput
    extends GSetEnterpriseIdentityProviderInput {
  @override
  final String? clientMutationId;
  @override
  final GSamlDigestAlgorithm digestMethod;
  @override
  final String enterpriseId;
  @override
  final String idpCertificate;
  @override
  final String? issuer;
  @override
  final GSamlSignatureAlgorithm signatureMethod;
  @override
  final String ssoUrl;

  factory _$GSetEnterpriseIdentityProviderInput(
          [void Function(GSetEnterpriseIdentityProviderInputBuilder)?
              updates]) =>
      (new GSetEnterpriseIdentityProviderInputBuilder()..update(updates))
          .build();

  _$GSetEnterpriseIdentityProviderInput._(
      {this.clientMutationId,
      required this.digestMethod,
      required this.enterpriseId,
      required this.idpCertificate,
      this.issuer,
      required this.signatureMethod,
      required this.ssoUrl})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        digestMethod, 'GSetEnterpriseIdentityProviderInput', 'digestMethod');
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GSetEnterpriseIdentityProviderInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(idpCertificate,
        'GSetEnterpriseIdentityProviderInput', 'idpCertificate');
    BuiltValueNullFieldError.checkNotNull(signatureMethod,
        'GSetEnterpriseIdentityProviderInput', 'signatureMethod');
    BuiltValueNullFieldError.checkNotNull(
        ssoUrl, 'GSetEnterpriseIdentityProviderInput', 'ssoUrl');
  }

  @override
  GSetEnterpriseIdentityProviderInput rebuild(
          void Function(GSetEnterpriseIdentityProviderInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSetEnterpriseIdentityProviderInputBuilder toBuilder() =>
      new GSetEnterpriseIdentityProviderInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSetEnterpriseIdentityProviderInput &&
        clientMutationId == other.clientMutationId &&
        digestMethod == other.digestMethod &&
        enterpriseId == other.enterpriseId &&
        idpCertificate == other.idpCertificate &&
        issuer == other.issuer &&
        signatureMethod == other.signatureMethod &&
        ssoUrl == other.ssoUrl;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc($jc(0, clientMutationId.hashCode),
                            digestMethod.hashCode),
                        enterpriseId.hashCode),
                    idpCertificate.hashCode),
                issuer.hashCode),
            signatureMethod.hashCode),
        ssoUrl.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSetEnterpriseIdentityProviderInput')
          ..add('clientMutationId', clientMutationId)
          ..add('digestMethod', digestMethod)
          ..add('enterpriseId', enterpriseId)
          ..add('idpCertificate', idpCertificate)
          ..add('issuer', issuer)
          ..add('signatureMethod', signatureMethod)
          ..add('ssoUrl', ssoUrl))
        .toString();
  }
}

class GSetEnterpriseIdentityProviderInputBuilder
    implements
        Builder<GSetEnterpriseIdentityProviderInput,
            GSetEnterpriseIdentityProviderInputBuilder> {
  _$GSetEnterpriseIdentityProviderInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GSamlDigestAlgorithm? _digestMethod;
  GSamlDigestAlgorithm? get digestMethod => _$this._digestMethod;
  set digestMethod(GSamlDigestAlgorithm? digestMethod) =>
      _$this._digestMethod = digestMethod;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _idpCertificate;
  String? get idpCertificate => _$this._idpCertificate;
  set idpCertificate(String? idpCertificate) =>
      _$this._idpCertificate = idpCertificate;

  String? _issuer;
  String? get issuer => _$this._issuer;
  set issuer(String? issuer) => _$this._issuer = issuer;

  GSamlSignatureAlgorithm? _signatureMethod;
  GSamlSignatureAlgorithm? get signatureMethod => _$this._signatureMethod;
  set signatureMethod(GSamlSignatureAlgorithm? signatureMethod) =>
      _$this._signatureMethod = signatureMethod;

  String? _ssoUrl;
  String? get ssoUrl => _$this._ssoUrl;
  set ssoUrl(String? ssoUrl) => _$this._ssoUrl = ssoUrl;

  GSetEnterpriseIdentityProviderInputBuilder();

  GSetEnterpriseIdentityProviderInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _digestMethod = $v.digestMethod;
      _enterpriseId = $v.enterpriseId;
      _idpCertificate = $v.idpCertificate;
      _issuer = $v.issuer;
      _signatureMethod = $v.signatureMethod;
      _ssoUrl = $v.ssoUrl;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSetEnterpriseIdentityProviderInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSetEnterpriseIdentityProviderInput;
  }

  @override
  void update(
      void Function(GSetEnterpriseIdentityProviderInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSetEnterpriseIdentityProviderInput build() {
    final _$result = _$v ??
        new _$GSetEnterpriseIdentityProviderInput._(
            clientMutationId: clientMutationId,
            digestMethod: BuiltValueNullFieldError.checkNotNull(digestMethod,
                'GSetEnterpriseIdentityProviderInput', 'digestMethod'),
            enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                'GSetEnterpriseIdentityProviderInput', 'enterpriseId'),
            idpCertificate: BuiltValueNullFieldError.checkNotNull(
                idpCertificate,
                'GSetEnterpriseIdentityProviderInput',
                'idpCertificate'),
            issuer: issuer,
            signatureMethod: BuiltValueNullFieldError.checkNotNull(
                signatureMethod,
                'GSetEnterpriseIdentityProviderInput',
                'signatureMethod'),
            ssoUrl: BuiltValueNullFieldError.checkNotNull(
                ssoUrl, 'GSetEnterpriseIdentityProviderInput', 'ssoUrl'));
    replace(_$result);
    return _$result;
  }
}

class _$GSetOrganizationInteractionLimitInput
    extends GSetOrganizationInteractionLimitInput {
  @override
  final String? clientMutationId;
  @override
  final GRepositoryInteractionLimitExpiry? expiry;
  @override
  final GRepositoryInteractionLimit limit;
  @override
  final String organizationId;

  factory _$GSetOrganizationInteractionLimitInput(
          [void Function(GSetOrganizationInteractionLimitInputBuilder)?
              updates]) =>
      (new GSetOrganizationInteractionLimitInputBuilder()..update(updates))
          .build();

  _$GSetOrganizationInteractionLimitInput._(
      {this.clientMutationId,
      this.expiry,
      required this.limit,
      required this.organizationId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        limit, 'GSetOrganizationInteractionLimitInput', 'limit');
    BuiltValueNullFieldError.checkNotNull(organizationId,
        'GSetOrganizationInteractionLimitInput', 'organizationId');
  }

  @override
  GSetOrganizationInteractionLimitInput rebuild(
          void Function(GSetOrganizationInteractionLimitInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSetOrganizationInteractionLimitInputBuilder toBuilder() =>
      new GSetOrganizationInteractionLimitInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSetOrganizationInteractionLimitInput &&
        clientMutationId == other.clientMutationId &&
        expiry == other.expiry &&
        limit == other.limit &&
        organizationId == other.organizationId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), expiry.hashCode),
            limit.hashCode),
        organizationId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSetOrganizationInteractionLimitInput')
          ..add('clientMutationId', clientMutationId)
          ..add('expiry', expiry)
          ..add('limit', limit)
          ..add('organizationId', organizationId))
        .toString();
  }
}

class GSetOrganizationInteractionLimitInputBuilder
    implements
        Builder<GSetOrganizationInteractionLimitInput,
            GSetOrganizationInteractionLimitInputBuilder> {
  _$GSetOrganizationInteractionLimitInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GRepositoryInteractionLimitExpiry? _expiry;
  GRepositoryInteractionLimitExpiry? get expiry => _$this._expiry;
  set expiry(GRepositoryInteractionLimitExpiry? expiry) =>
      _$this._expiry = expiry;

  GRepositoryInteractionLimit? _limit;
  GRepositoryInteractionLimit? get limit => _$this._limit;
  set limit(GRepositoryInteractionLimit? limit) => _$this._limit = limit;

  String? _organizationId;
  String? get organizationId => _$this._organizationId;
  set organizationId(String? organizationId) =>
      _$this._organizationId = organizationId;

  GSetOrganizationInteractionLimitInputBuilder();

  GSetOrganizationInteractionLimitInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _expiry = $v.expiry;
      _limit = $v.limit;
      _organizationId = $v.organizationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSetOrganizationInteractionLimitInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSetOrganizationInteractionLimitInput;
  }

  @override
  void update(
      void Function(GSetOrganizationInteractionLimitInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSetOrganizationInteractionLimitInput build() {
    final _$result = _$v ??
        new _$GSetOrganizationInteractionLimitInput._(
            clientMutationId: clientMutationId,
            expiry: expiry,
            limit: BuiltValueNullFieldError.checkNotNull(
                limit, 'GSetOrganizationInteractionLimitInput', 'limit'),
            organizationId: BuiltValueNullFieldError.checkNotNull(
                organizationId,
                'GSetOrganizationInteractionLimitInput',
                'organizationId'));
    replace(_$result);
    return _$result;
  }
}

class _$GSetRepositoryInteractionLimitInput
    extends GSetRepositoryInteractionLimitInput {
  @override
  final String? clientMutationId;
  @override
  final GRepositoryInteractionLimitExpiry? expiry;
  @override
  final GRepositoryInteractionLimit limit;
  @override
  final String repositoryId;

  factory _$GSetRepositoryInteractionLimitInput(
          [void Function(GSetRepositoryInteractionLimitInputBuilder)?
              updates]) =>
      (new GSetRepositoryInteractionLimitInputBuilder()..update(updates))
          .build();

  _$GSetRepositoryInteractionLimitInput._(
      {this.clientMutationId,
      this.expiry,
      required this.limit,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        limit, 'GSetRepositoryInteractionLimitInput', 'limit');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GSetRepositoryInteractionLimitInput', 'repositoryId');
  }

  @override
  GSetRepositoryInteractionLimitInput rebuild(
          void Function(GSetRepositoryInteractionLimitInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSetRepositoryInteractionLimitInputBuilder toBuilder() =>
      new GSetRepositoryInteractionLimitInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSetRepositoryInteractionLimitInput &&
        clientMutationId == other.clientMutationId &&
        expiry == other.expiry &&
        limit == other.limit &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), expiry.hashCode),
            limit.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSetRepositoryInteractionLimitInput')
          ..add('clientMutationId', clientMutationId)
          ..add('expiry', expiry)
          ..add('limit', limit)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GSetRepositoryInteractionLimitInputBuilder
    implements
        Builder<GSetRepositoryInteractionLimitInput,
            GSetRepositoryInteractionLimitInputBuilder> {
  _$GSetRepositoryInteractionLimitInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GRepositoryInteractionLimitExpiry? _expiry;
  GRepositoryInteractionLimitExpiry? get expiry => _$this._expiry;
  set expiry(GRepositoryInteractionLimitExpiry? expiry) =>
      _$this._expiry = expiry;

  GRepositoryInteractionLimit? _limit;
  GRepositoryInteractionLimit? get limit => _$this._limit;
  set limit(GRepositoryInteractionLimit? limit) => _$this._limit = limit;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GSetRepositoryInteractionLimitInputBuilder();

  GSetRepositoryInteractionLimitInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _expiry = $v.expiry;
      _limit = $v.limit;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSetRepositoryInteractionLimitInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSetRepositoryInteractionLimitInput;
  }

  @override
  void update(
      void Function(GSetRepositoryInteractionLimitInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSetRepositoryInteractionLimitInput build() {
    final _$result = _$v ??
        new _$GSetRepositoryInteractionLimitInput._(
            clientMutationId: clientMutationId,
            expiry: expiry,
            limit: BuiltValueNullFieldError.checkNotNull(
                limit, 'GSetRepositoryInteractionLimitInput', 'limit'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(repositoryId,
                'GSetRepositoryInteractionLimitInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GSetUserInteractionLimitInput extends GSetUserInteractionLimitInput {
  @override
  final String? clientMutationId;
  @override
  final GRepositoryInteractionLimitExpiry? expiry;
  @override
  final GRepositoryInteractionLimit limit;
  @override
  final String userId;

  factory _$GSetUserInteractionLimitInput(
          [void Function(GSetUserInteractionLimitInputBuilder)? updates]) =>
      (new GSetUserInteractionLimitInputBuilder()..update(updates)).build();

  _$GSetUserInteractionLimitInput._(
      {this.clientMutationId,
      this.expiry,
      required this.limit,
      required this.userId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        limit, 'GSetUserInteractionLimitInput', 'limit');
    BuiltValueNullFieldError.checkNotNull(
        userId, 'GSetUserInteractionLimitInput', 'userId');
  }

  @override
  GSetUserInteractionLimitInput rebuild(
          void Function(GSetUserInteractionLimitInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSetUserInteractionLimitInputBuilder toBuilder() =>
      new GSetUserInteractionLimitInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSetUserInteractionLimitInput &&
        clientMutationId == other.clientMutationId &&
        expiry == other.expiry &&
        limit == other.limit &&
        userId == other.userId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), expiry.hashCode),
            limit.hashCode),
        userId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSetUserInteractionLimitInput')
          ..add('clientMutationId', clientMutationId)
          ..add('expiry', expiry)
          ..add('limit', limit)
          ..add('userId', userId))
        .toString();
  }
}

class GSetUserInteractionLimitInputBuilder
    implements
        Builder<GSetUserInteractionLimitInput,
            GSetUserInteractionLimitInputBuilder> {
  _$GSetUserInteractionLimitInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GRepositoryInteractionLimitExpiry? _expiry;
  GRepositoryInteractionLimitExpiry? get expiry => _$this._expiry;
  set expiry(GRepositoryInteractionLimitExpiry? expiry) =>
      _$this._expiry = expiry;

  GRepositoryInteractionLimit? _limit;
  GRepositoryInteractionLimit? get limit => _$this._limit;
  set limit(GRepositoryInteractionLimit? limit) => _$this._limit = limit;

  String? _userId;
  String? get userId => _$this._userId;
  set userId(String? userId) => _$this._userId = userId;

  GSetUserInteractionLimitInputBuilder();

  GSetUserInteractionLimitInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _expiry = $v.expiry;
      _limit = $v.limit;
      _userId = $v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSetUserInteractionLimitInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSetUserInteractionLimitInput;
  }

  @override
  void update(void Function(GSetUserInteractionLimitInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSetUserInteractionLimitInput build() {
    final _$result = _$v ??
        new _$GSetUserInteractionLimitInput._(
            clientMutationId: clientMutationId,
            expiry: expiry,
            limit: BuiltValueNullFieldError.checkNotNull(
                limit, 'GSetUserInteractionLimitInput', 'limit'),
            userId: BuiltValueNullFieldError.checkNotNull(
                userId, 'GSetUserInteractionLimitInput', 'userId'));
    replace(_$result);
    return _$result;
  }
}

class _$GSponsorableOrder extends GSponsorableOrder {
  @override
  final GOrderDirection direction;
  @override
  final GSponsorableOrderField field;

  factory _$GSponsorableOrder(
          [void Function(GSponsorableOrderBuilder)? updates]) =>
      (new GSponsorableOrderBuilder()..update(updates)).build();

  _$GSponsorableOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GSponsorableOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GSponsorableOrder', 'field');
  }

  @override
  GSponsorableOrder rebuild(void Function(GSponsorableOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSponsorableOrderBuilder toBuilder() =>
      new GSponsorableOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSponsorableOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSponsorableOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GSponsorableOrderBuilder
    implements Builder<GSponsorableOrder, GSponsorableOrderBuilder> {
  _$GSponsorableOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GSponsorableOrderField? _field;
  GSponsorableOrderField? get field => _$this._field;
  set field(GSponsorableOrderField? field) => _$this._field = field;

  GSponsorableOrderBuilder();

  GSponsorableOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSponsorableOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSponsorableOrder;
  }

  @override
  void update(void Function(GSponsorableOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSponsorableOrder build() {
    final _$result = _$v ??
        new _$GSponsorableOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GSponsorableOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GSponsorableOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GSponsorsTierOrder extends GSponsorsTierOrder {
  @override
  final GOrderDirection direction;
  @override
  final GSponsorsTierOrderField field;

  factory _$GSponsorsTierOrder(
          [void Function(GSponsorsTierOrderBuilder)? updates]) =>
      (new GSponsorsTierOrderBuilder()..update(updates)).build();

  _$GSponsorsTierOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GSponsorsTierOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GSponsorsTierOrder', 'field');
  }

  @override
  GSponsorsTierOrder rebuild(
          void Function(GSponsorsTierOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSponsorsTierOrderBuilder toBuilder() =>
      new GSponsorsTierOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSponsorsTierOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSponsorsTierOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GSponsorsTierOrderBuilder
    implements Builder<GSponsorsTierOrder, GSponsorsTierOrderBuilder> {
  _$GSponsorsTierOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GSponsorsTierOrderField? _field;
  GSponsorsTierOrderField? get field => _$this._field;
  set field(GSponsorsTierOrderField? field) => _$this._field = field;

  GSponsorsTierOrderBuilder();

  GSponsorsTierOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSponsorsTierOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSponsorsTierOrder;
  }

  @override
  void update(void Function(GSponsorsTierOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSponsorsTierOrder build() {
    final _$result = _$v ??
        new _$GSponsorsTierOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GSponsorsTierOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GSponsorsTierOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GSponsorshipOrder extends GSponsorshipOrder {
  @override
  final GOrderDirection direction;
  @override
  final GSponsorshipOrderField field;

  factory _$GSponsorshipOrder(
          [void Function(GSponsorshipOrderBuilder)? updates]) =>
      (new GSponsorshipOrderBuilder()..update(updates)).build();

  _$GSponsorshipOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GSponsorshipOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GSponsorshipOrder', 'field');
  }

  @override
  GSponsorshipOrder rebuild(void Function(GSponsorshipOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSponsorshipOrderBuilder toBuilder() =>
      new GSponsorshipOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSponsorshipOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSponsorshipOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GSponsorshipOrderBuilder
    implements Builder<GSponsorshipOrder, GSponsorshipOrderBuilder> {
  _$GSponsorshipOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GSponsorshipOrderField? _field;
  GSponsorshipOrderField? get field => _$this._field;
  set field(GSponsorshipOrderField? field) => _$this._field = field;

  GSponsorshipOrderBuilder();

  GSponsorshipOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSponsorshipOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSponsorshipOrder;
  }

  @override
  void update(void Function(GSponsorshipOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSponsorshipOrder build() {
    final _$result = _$v ??
        new _$GSponsorshipOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GSponsorshipOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GSponsorshipOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GStarOrder extends GStarOrder {
  @override
  final GOrderDirection direction;
  @override
  final GStarOrderField field;

  factory _$GStarOrder([void Function(GStarOrderBuilder)? updates]) =>
      (new GStarOrderBuilder()..update(updates)).build();

  _$GStarOrder._({required this.direction, required this.field}) : super._() {
    BuiltValueNullFieldError.checkNotNull(direction, 'GStarOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GStarOrder', 'field');
  }

  @override
  GStarOrder rebuild(void Function(GStarOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GStarOrderBuilder toBuilder() => new GStarOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GStarOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GStarOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GStarOrderBuilder implements Builder<GStarOrder, GStarOrderBuilder> {
  _$GStarOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GStarOrderField? _field;
  GStarOrderField? get field => _$this._field;
  set field(GStarOrderField? field) => _$this._field = field;

  GStarOrderBuilder();

  GStarOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GStarOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GStarOrder;
  }

  @override
  void update(void Function(GStarOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GStarOrder build() {
    final _$result = _$v ??
        new _$GStarOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GStarOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GStarOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GSubmitPullRequestReviewInput extends GSubmitPullRequestReviewInput {
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final GPullRequestReviewEvent event;
  @override
  final String? pullRequestId;
  @override
  final String? pullRequestReviewId;

  factory _$GSubmitPullRequestReviewInput(
          [void Function(GSubmitPullRequestReviewInputBuilder)? updates]) =>
      (new GSubmitPullRequestReviewInputBuilder()..update(updates)).build();

  _$GSubmitPullRequestReviewInput._(
      {this.body,
      this.clientMutationId,
      required this.event,
      this.pullRequestId,
      this.pullRequestReviewId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        event, 'GSubmitPullRequestReviewInput', 'event');
  }

  @override
  GSubmitPullRequestReviewInput rebuild(
          void Function(GSubmitPullRequestReviewInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GSubmitPullRequestReviewInputBuilder toBuilder() =>
      new GSubmitPullRequestReviewInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GSubmitPullRequestReviewInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        event == other.event &&
        pullRequestId == other.pullRequestId &&
        pullRequestReviewId == other.pullRequestReviewId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
                event.hashCode),
            pullRequestId.hashCode),
        pullRequestReviewId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GSubmitPullRequestReviewInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('event', event)
          ..add('pullRequestId', pullRequestId)
          ..add('pullRequestReviewId', pullRequestReviewId))
        .toString();
  }
}

class GSubmitPullRequestReviewInputBuilder
    implements
        Builder<GSubmitPullRequestReviewInput,
            GSubmitPullRequestReviewInputBuilder> {
  _$GSubmitPullRequestReviewInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GPullRequestReviewEvent? _event;
  GPullRequestReviewEvent? get event => _$this._event;
  set event(GPullRequestReviewEvent? event) => _$this._event = event;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  String? _pullRequestReviewId;
  String? get pullRequestReviewId => _$this._pullRequestReviewId;
  set pullRequestReviewId(String? pullRequestReviewId) =>
      _$this._pullRequestReviewId = pullRequestReviewId;

  GSubmitPullRequestReviewInputBuilder();

  GSubmitPullRequestReviewInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _event = $v.event;
      _pullRequestId = $v.pullRequestId;
      _pullRequestReviewId = $v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSubmitPullRequestReviewInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GSubmitPullRequestReviewInput;
  }

  @override
  void update(void Function(GSubmitPullRequestReviewInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GSubmitPullRequestReviewInput build() {
    final _$result = _$v ??
        new _$GSubmitPullRequestReviewInput._(
            body: body,
            clientMutationId: clientMutationId,
            event: BuiltValueNullFieldError.checkNotNull(
                event, 'GSubmitPullRequestReviewInput', 'event'),
            pullRequestId: pullRequestId,
            pullRequestReviewId: pullRequestReviewId);
    replace(_$result);
    return _$result;
  }
}

class _$GTeamDiscussionCommentOrder extends GTeamDiscussionCommentOrder {
  @override
  final GOrderDirection direction;
  @override
  final GTeamDiscussionCommentOrderField field;

  factory _$GTeamDiscussionCommentOrder(
          [void Function(GTeamDiscussionCommentOrderBuilder)? updates]) =>
      (new GTeamDiscussionCommentOrderBuilder()..update(updates)).build();

  _$GTeamDiscussionCommentOrder._(
      {required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GTeamDiscussionCommentOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GTeamDiscussionCommentOrder', 'field');
  }

  @override
  GTeamDiscussionCommentOrder rebuild(
          void Function(GTeamDiscussionCommentOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GTeamDiscussionCommentOrderBuilder toBuilder() =>
      new GTeamDiscussionCommentOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GTeamDiscussionCommentOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GTeamDiscussionCommentOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GTeamDiscussionCommentOrderBuilder
    implements
        Builder<GTeamDiscussionCommentOrder,
            GTeamDiscussionCommentOrderBuilder> {
  _$GTeamDiscussionCommentOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GTeamDiscussionCommentOrderField? _field;
  GTeamDiscussionCommentOrderField? get field => _$this._field;
  set field(GTeamDiscussionCommentOrderField? field) => _$this._field = field;

  GTeamDiscussionCommentOrderBuilder();

  GTeamDiscussionCommentOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamDiscussionCommentOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GTeamDiscussionCommentOrder;
  }

  @override
  void update(void Function(GTeamDiscussionCommentOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GTeamDiscussionCommentOrder build() {
    final _$result = _$v ??
        new _$GTeamDiscussionCommentOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GTeamDiscussionCommentOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GTeamDiscussionCommentOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GTeamDiscussionOrder extends GTeamDiscussionOrder {
  @override
  final GOrderDirection direction;
  @override
  final GTeamDiscussionOrderField field;

  factory _$GTeamDiscussionOrder(
          [void Function(GTeamDiscussionOrderBuilder)? updates]) =>
      (new GTeamDiscussionOrderBuilder()..update(updates)).build();

  _$GTeamDiscussionOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GTeamDiscussionOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GTeamDiscussionOrder', 'field');
  }

  @override
  GTeamDiscussionOrder rebuild(
          void Function(GTeamDiscussionOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GTeamDiscussionOrderBuilder toBuilder() =>
      new GTeamDiscussionOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GTeamDiscussionOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GTeamDiscussionOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GTeamDiscussionOrderBuilder
    implements Builder<GTeamDiscussionOrder, GTeamDiscussionOrderBuilder> {
  _$GTeamDiscussionOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GTeamDiscussionOrderField? _field;
  GTeamDiscussionOrderField? get field => _$this._field;
  set field(GTeamDiscussionOrderField? field) => _$this._field = field;

  GTeamDiscussionOrderBuilder();

  GTeamDiscussionOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamDiscussionOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GTeamDiscussionOrder;
  }

  @override
  void update(void Function(GTeamDiscussionOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GTeamDiscussionOrder build() {
    final _$result = _$v ??
        new _$GTeamDiscussionOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GTeamDiscussionOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GTeamDiscussionOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GTeamMemberOrder extends GTeamMemberOrder {
  @override
  final GOrderDirection direction;
  @override
  final GTeamMemberOrderField field;

  factory _$GTeamMemberOrder(
          [void Function(GTeamMemberOrderBuilder)? updates]) =>
      (new GTeamMemberOrderBuilder()..update(updates)).build();

  _$GTeamMemberOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GTeamMemberOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GTeamMemberOrder', 'field');
  }

  @override
  GTeamMemberOrder rebuild(void Function(GTeamMemberOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GTeamMemberOrderBuilder toBuilder() =>
      new GTeamMemberOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GTeamMemberOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GTeamMemberOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GTeamMemberOrderBuilder
    implements Builder<GTeamMemberOrder, GTeamMemberOrderBuilder> {
  _$GTeamMemberOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GTeamMemberOrderField? _field;
  GTeamMemberOrderField? get field => _$this._field;
  set field(GTeamMemberOrderField? field) => _$this._field = field;

  GTeamMemberOrderBuilder();

  GTeamMemberOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamMemberOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GTeamMemberOrder;
  }

  @override
  void update(void Function(GTeamMemberOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GTeamMemberOrder build() {
    final _$result = _$v ??
        new _$GTeamMemberOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GTeamMemberOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GTeamMemberOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GTeamOrder extends GTeamOrder {
  @override
  final GOrderDirection direction;
  @override
  final GTeamOrderField field;

  factory _$GTeamOrder([void Function(GTeamOrderBuilder)? updates]) =>
      (new GTeamOrderBuilder()..update(updates)).build();

  _$GTeamOrder._({required this.direction, required this.field}) : super._() {
    BuiltValueNullFieldError.checkNotNull(direction, 'GTeamOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GTeamOrder', 'field');
  }

  @override
  GTeamOrder rebuild(void Function(GTeamOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GTeamOrderBuilder toBuilder() => new GTeamOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GTeamOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GTeamOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GTeamOrderBuilder implements Builder<GTeamOrder, GTeamOrderBuilder> {
  _$GTeamOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GTeamOrderField? _field;
  GTeamOrderField? get field => _$this._field;
  set field(GTeamOrderField? field) => _$this._field = field;

  GTeamOrderBuilder();

  GTeamOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GTeamOrder;
  }

  @override
  void update(void Function(GTeamOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GTeamOrder build() {
    final _$result = _$v ??
        new _$GTeamOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GTeamOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GTeamOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GTeamRepositoryOrder extends GTeamRepositoryOrder {
  @override
  final GOrderDirection direction;
  @override
  final GTeamRepositoryOrderField field;

  factory _$GTeamRepositoryOrder(
          [void Function(GTeamRepositoryOrderBuilder)? updates]) =>
      (new GTeamRepositoryOrderBuilder()..update(updates)).build();

  _$GTeamRepositoryOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GTeamRepositoryOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GTeamRepositoryOrder', 'field');
  }

  @override
  GTeamRepositoryOrder rebuild(
          void Function(GTeamRepositoryOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GTeamRepositoryOrderBuilder toBuilder() =>
      new GTeamRepositoryOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GTeamRepositoryOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GTeamRepositoryOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GTeamRepositoryOrderBuilder
    implements Builder<GTeamRepositoryOrder, GTeamRepositoryOrderBuilder> {
  _$GTeamRepositoryOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GTeamRepositoryOrderField? _field;
  GTeamRepositoryOrderField? get field => _$this._field;
  set field(GTeamRepositoryOrderField? field) => _$this._field = field;

  GTeamRepositoryOrderBuilder();

  GTeamRepositoryOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamRepositoryOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GTeamRepositoryOrder;
  }

  @override
  void update(void Function(GTeamRepositoryOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GTeamRepositoryOrder build() {
    final _$result = _$v ??
        new _$GTeamRepositoryOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GTeamRepositoryOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GTeamRepositoryOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GTransferIssueInput extends GTransferIssueInput {
  @override
  final String? clientMutationId;
  @override
  final String issueId;
  @override
  final String repositoryId;

  factory _$GTransferIssueInput(
          [void Function(GTransferIssueInputBuilder)? updates]) =>
      (new GTransferIssueInputBuilder()..update(updates)).build();

  _$GTransferIssueInput._(
      {this.clientMutationId,
      required this.issueId,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        issueId, 'GTransferIssueInput', 'issueId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GTransferIssueInput', 'repositoryId');
  }

  @override
  GTransferIssueInput rebuild(
          void Function(GTransferIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GTransferIssueInputBuilder toBuilder() =>
      new GTransferIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GTransferIssueInput &&
        clientMutationId == other.clientMutationId &&
        issueId == other.issueId &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), issueId.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GTransferIssueInput')
          ..add('clientMutationId', clientMutationId)
          ..add('issueId', issueId)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GTransferIssueInputBuilder
    implements Builder<GTransferIssueInput, GTransferIssueInputBuilder> {
  _$GTransferIssueInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _issueId;
  String? get issueId => _$this._issueId;
  set issueId(String? issueId) => _$this._issueId = issueId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GTransferIssueInputBuilder();

  GTransferIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _issueId = $v.issueId;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTransferIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GTransferIssueInput;
  }

  @override
  void update(void Function(GTransferIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GTransferIssueInput build() {
    final _$result = _$v ??
        new _$GTransferIssueInput._(
            clientMutationId: clientMutationId,
            issueId: BuiltValueNullFieldError.checkNotNull(
                issueId, 'GTransferIssueInput', 'issueId'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GTransferIssueInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnarchiveRepositoryInput extends GUnarchiveRepositoryInput {
  @override
  final String? clientMutationId;
  @override
  final String repositoryId;

  factory _$GUnarchiveRepositoryInput(
          [void Function(GUnarchiveRepositoryInputBuilder)? updates]) =>
      (new GUnarchiveRepositoryInputBuilder()..update(updates)).build();

  _$GUnarchiveRepositoryInput._(
      {this.clientMutationId, required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GUnarchiveRepositoryInput', 'repositoryId');
  }

  @override
  GUnarchiveRepositoryInput rebuild(
          void Function(GUnarchiveRepositoryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnarchiveRepositoryInputBuilder toBuilder() =>
      new GUnarchiveRepositoryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnarchiveRepositoryInput &&
        clientMutationId == other.clientMutationId &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnarchiveRepositoryInput')
          ..add('clientMutationId', clientMutationId)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GUnarchiveRepositoryInputBuilder
    implements
        Builder<GUnarchiveRepositoryInput, GUnarchiveRepositoryInputBuilder> {
  _$GUnarchiveRepositoryInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GUnarchiveRepositoryInputBuilder();

  GUnarchiveRepositoryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnarchiveRepositoryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnarchiveRepositoryInput;
  }

  @override
  void update(void Function(GUnarchiveRepositoryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnarchiveRepositoryInput build() {
    final _$result = _$v ??
        new _$GUnarchiveRepositoryInput._(
            clientMutationId: clientMutationId,
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GUnarchiveRepositoryInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnfollowUserInput extends GUnfollowUserInput {
  @override
  final String? clientMutationId;
  @override
  final String userId;

  factory _$GUnfollowUserInput(
          [void Function(GUnfollowUserInputBuilder)? updates]) =>
      (new GUnfollowUserInputBuilder()..update(updates)).build();

  _$GUnfollowUserInput._({this.clientMutationId, required this.userId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        userId, 'GUnfollowUserInput', 'userId');
  }

  @override
  GUnfollowUserInput rebuild(
          void Function(GUnfollowUserInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnfollowUserInputBuilder toBuilder() =>
      new GUnfollowUserInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnfollowUserInput &&
        clientMutationId == other.clientMutationId &&
        userId == other.userId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), userId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnfollowUserInput')
          ..add('clientMutationId', clientMutationId)
          ..add('userId', userId))
        .toString();
  }
}

class GUnfollowUserInputBuilder
    implements Builder<GUnfollowUserInput, GUnfollowUserInputBuilder> {
  _$GUnfollowUserInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _userId;
  String? get userId => _$this._userId;
  set userId(String? userId) => _$this._userId = userId;

  GUnfollowUserInputBuilder();

  GUnfollowUserInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _userId = $v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnfollowUserInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnfollowUserInput;
  }

  @override
  void update(void Function(GUnfollowUserInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnfollowUserInput build() {
    final _$result = _$v ??
        new _$GUnfollowUserInput._(
            clientMutationId: clientMutationId,
            userId: BuiltValueNullFieldError.checkNotNull(
                userId, 'GUnfollowUserInput', 'userId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnlinkRepositoryFromProjectInput
    extends GUnlinkRepositoryFromProjectInput {
  @override
  final String? clientMutationId;
  @override
  final String projectId;
  @override
  final String repositoryId;

  factory _$GUnlinkRepositoryFromProjectInput(
          [void Function(GUnlinkRepositoryFromProjectInputBuilder)? updates]) =>
      (new GUnlinkRepositoryFromProjectInputBuilder()..update(updates)).build();

  _$GUnlinkRepositoryFromProjectInput._(
      {this.clientMutationId,
      required this.projectId,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        projectId, 'GUnlinkRepositoryFromProjectInput', 'projectId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GUnlinkRepositoryFromProjectInput', 'repositoryId');
  }

  @override
  GUnlinkRepositoryFromProjectInput rebuild(
          void Function(GUnlinkRepositoryFromProjectInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnlinkRepositoryFromProjectInputBuilder toBuilder() =>
      new GUnlinkRepositoryFromProjectInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnlinkRepositoryFromProjectInput &&
        clientMutationId == other.clientMutationId &&
        projectId == other.projectId &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), projectId.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnlinkRepositoryFromProjectInput')
          ..add('clientMutationId', clientMutationId)
          ..add('projectId', projectId)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GUnlinkRepositoryFromProjectInputBuilder
    implements
        Builder<GUnlinkRepositoryFromProjectInput,
            GUnlinkRepositoryFromProjectInputBuilder> {
  _$GUnlinkRepositoryFromProjectInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _projectId;
  String? get projectId => _$this._projectId;
  set projectId(String? projectId) => _$this._projectId = projectId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GUnlinkRepositoryFromProjectInputBuilder();

  GUnlinkRepositoryFromProjectInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _projectId = $v.projectId;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnlinkRepositoryFromProjectInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnlinkRepositoryFromProjectInput;
  }

  @override
  void update(
      void Function(GUnlinkRepositoryFromProjectInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnlinkRepositoryFromProjectInput build() {
    final _$result = _$v ??
        new _$GUnlinkRepositoryFromProjectInput._(
            clientMutationId: clientMutationId,
            projectId: BuiltValueNullFieldError.checkNotNull(
                projectId, 'GUnlinkRepositoryFromProjectInput', 'projectId'),
            repositoryId: BuiltValueNullFieldError.checkNotNull(repositoryId,
                'GUnlinkRepositoryFromProjectInput', 'repositoryId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnlockLockableInput extends GUnlockLockableInput {
  @override
  final String? clientMutationId;
  @override
  final String lockableId;

  factory _$GUnlockLockableInput(
          [void Function(GUnlockLockableInputBuilder)? updates]) =>
      (new GUnlockLockableInputBuilder()..update(updates)).build();

  _$GUnlockLockableInput._({this.clientMutationId, required this.lockableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        lockableId, 'GUnlockLockableInput', 'lockableId');
  }

  @override
  GUnlockLockableInput rebuild(
          void Function(GUnlockLockableInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnlockLockableInputBuilder toBuilder() =>
      new GUnlockLockableInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnlockLockableInput &&
        clientMutationId == other.clientMutationId &&
        lockableId == other.lockableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), lockableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnlockLockableInput')
          ..add('clientMutationId', clientMutationId)
          ..add('lockableId', lockableId))
        .toString();
  }
}

class GUnlockLockableInputBuilder
    implements Builder<GUnlockLockableInput, GUnlockLockableInputBuilder> {
  _$GUnlockLockableInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _lockableId;
  String? get lockableId => _$this._lockableId;
  set lockableId(String? lockableId) => _$this._lockableId = lockableId;

  GUnlockLockableInputBuilder();

  GUnlockLockableInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _lockableId = $v.lockableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnlockLockableInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnlockLockableInput;
  }

  @override
  void update(void Function(GUnlockLockableInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnlockLockableInput build() {
    final _$result = _$v ??
        new _$GUnlockLockableInput._(
            clientMutationId: clientMutationId,
            lockableId: BuiltValueNullFieldError.checkNotNull(
                lockableId, 'GUnlockLockableInput', 'lockableId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnmarkDiscussionCommentAsAnswerInput
    extends GUnmarkDiscussionCommentAsAnswerInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GUnmarkDiscussionCommentAsAnswerInput(
          [void Function(GUnmarkDiscussionCommentAsAnswerInputBuilder)?
              updates]) =>
      (new GUnmarkDiscussionCommentAsAnswerInputBuilder()..update(updates))
          .build();

  _$GUnmarkDiscussionCommentAsAnswerInput._(
      {this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GUnmarkDiscussionCommentAsAnswerInput', 'id');
  }

  @override
  GUnmarkDiscussionCommentAsAnswerInput rebuild(
          void Function(GUnmarkDiscussionCommentAsAnswerInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnmarkDiscussionCommentAsAnswerInputBuilder toBuilder() =>
      new GUnmarkDiscussionCommentAsAnswerInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnmarkDiscussionCommentAsAnswerInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnmarkDiscussionCommentAsAnswerInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GUnmarkDiscussionCommentAsAnswerInputBuilder
    implements
        Builder<GUnmarkDiscussionCommentAsAnswerInput,
            GUnmarkDiscussionCommentAsAnswerInputBuilder> {
  _$GUnmarkDiscussionCommentAsAnswerInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GUnmarkDiscussionCommentAsAnswerInputBuilder();

  GUnmarkDiscussionCommentAsAnswerInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnmarkDiscussionCommentAsAnswerInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnmarkDiscussionCommentAsAnswerInput;
  }

  @override
  void update(
      void Function(GUnmarkDiscussionCommentAsAnswerInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnmarkDiscussionCommentAsAnswerInput build() {
    final _$result = _$v ??
        new _$GUnmarkDiscussionCommentAsAnswerInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GUnmarkDiscussionCommentAsAnswerInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnmarkFileAsViewedInput extends GUnmarkFileAsViewedInput {
  @override
  final String? clientMutationId;
  @override
  final String path;
  @override
  final String pullRequestId;

  factory _$GUnmarkFileAsViewedInput(
          [void Function(GUnmarkFileAsViewedInputBuilder)? updates]) =>
      (new GUnmarkFileAsViewedInputBuilder()..update(updates)).build();

  _$GUnmarkFileAsViewedInput._(
      {this.clientMutationId, required this.path, required this.pullRequestId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        path, 'GUnmarkFileAsViewedInput', 'path');
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GUnmarkFileAsViewedInput', 'pullRequestId');
  }

  @override
  GUnmarkFileAsViewedInput rebuild(
          void Function(GUnmarkFileAsViewedInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnmarkFileAsViewedInputBuilder toBuilder() =>
      new GUnmarkFileAsViewedInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnmarkFileAsViewedInput &&
        clientMutationId == other.clientMutationId &&
        path == other.path &&
        pullRequestId == other.pullRequestId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), path.hashCode),
        pullRequestId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnmarkFileAsViewedInput')
          ..add('clientMutationId', clientMutationId)
          ..add('path', path)
          ..add('pullRequestId', pullRequestId))
        .toString();
  }
}

class GUnmarkFileAsViewedInputBuilder
    implements
        Builder<GUnmarkFileAsViewedInput, GUnmarkFileAsViewedInputBuilder> {
  _$GUnmarkFileAsViewedInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _path;
  String? get path => _$this._path;
  set path(String? path) => _$this._path = path;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GUnmarkFileAsViewedInputBuilder();

  GUnmarkFileAsViewedInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _path = $v.path;
      _pullRequestId = $v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnmarkFileAsViewedInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnmarkFileAsViewedInput;
  }

  @override
  void update(void Function(GUnmarkFileAsViewedInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnmarkFileAsViewedInput build() {
    final _$result = _$v ??
        new _$GUnmarkFileAsViewedInput._(
            clientMutationId: clientMutationId,
            path: BuiltValueNullFieldError.checkNotNull(
                path, 'GUnmarkFileAsViewedInput', 'path'),
            pullRequestId: BuiltValueNullFieldError.checkNotNull(
                pullRequestId, 'GUnmarkFileAsViewedInput', 'pullRequestId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnmarkIssueAsDuplicateInput extends GUnmarkIssueAsDuplicateInput {
  @override
  final String canonicalId;
  @override
  final String? clientMutationId;
  @override
  final String duplicateId;

  factory _$GUnmarkIssueAsDuplicateInput(
          [void Function(GUnmarkIssueAsDuplicateInputBuilder)? updates]) =>
      (new GUnmarkIssueAsDuplicateInputBuilder()..update(updates)).build();

  _$GUnmarkIssueAsDuplicateInput._(
      {required this.canonicalId,
      this.clientMutationId,
      required this.duplicateId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        canonicalId, 'GUnmarkIssueAsDuplicateInput', 'canonicalId');
    BuiltValueNullFieldError.checkNotNull(
        duplicateId, 'GUnmarkIssueAsDuplicateInput', 'duplicateId');
  }

  @override
  GUnmarkIssueAsDuplicateInput rebuild(
          void Function(GUnmarkIssueAsDuplicateInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnmarkIssueAsDuplicateInputBuilder toBuilder() =>
      new GUnmarkIssueAsDuplicateInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnmarkIssueAsDuplicateInput &&
        canonicalId == other.canonicalId &&
        clientMutationId == other.clientMutationId &&
        duplicateId == other.duplicateId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, canonicalId.hashCode), clientMutationId.hashCode),
        duplicateId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnmarkIssueAsDuplicateInput')
          ..add('canonicalId', canonicalId)
          ..add('clientMutationId', clientMutationId)
          ..add('duplicateId', duplicateId))
        .toString();
  }
}

class GUnmarkIssueAsDuplicateInputBuilder
    implements
        Builder<GUnmarkIssueAsDuplicateInput,
            GUnmarkIssueAsDuplicateInputBuilder> {
  _$GUnmarkIssueAsDuplicateInput? _$v;

  String? _canonicalId;
  String? get canonicalId => _$this._canonicalId;
  set canonicalId(String? canonicalId) => _$this._canonicalId = canonicalId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _duplicateId;
  String? get duplicateId => _$this._duplicateId;
  set duplicateId(String? duplicateId) => _$this._duplicateId = duplicateId;

  GUnmarkIssueAsDuplicateInputBuilder();

  GUnmarkIssueAsDuplicateInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _canonicalId = $v.canonicalId;
      _clientMutationId = $v.clientMutationId;
      _duplicateId = $v.duplicateId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnmarkIssueAsDuplicateInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnmarkIssueAsDuplicateInput;
  }

  @override
  void update(void Function(GUnmarkIssueAsDuplicateInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnmarkIssueAsDuplicateInput build() {
    final _$result = _$v ??
        new _$GUnmarkIssueAsDuplicateInput._(
            canonicalId: BuiltValueNullFieldError.checkNotNull(
                canonicalId, 'GUnmarkIssueAsDuplicateInput', 'canonicalId'),
            clientMutationId: clientMutationId,
            duplicateId: BuiltValueNullFieldError.checkNotNull(
                duplicateId, 'GUnmarkIssueAsDuplicateInput', 'duplicateId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnminimizeCommentInput extends GUnminimizeCommentInput {
  @override
  final String? clientMutationId;
  @override
  final String subjectId;

  factory _$GUnminimizeCommentInput(
          [void Function(GUnminimizeCommentInputBuilder)? updates]) =>
      (new GUnminimizeCommentInputBuilder()..update(updates)).build();

  _$GUnminimizeCommentInput._({this.clientMutationId, required this.subjectId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        subjectId, 'GUnminimizeCommentInput', 'subjectId');
  }

  @override
  GUnminimizeCommentInput rebuild(
          void Function(GUnminimizeCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnminimizeCommentInputBuilder toBuilder() =>
      new GUnminimizeCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnminimizeCommentInput &&
        clientMutationId == other.clientMutationId &&
        subjectId == other.subjectId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), subjectId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnminimizeCommentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('subjectId', subjectId))
        .toString();
  }
}

class GUnminimizeCommentInputBuilder
    implements
        Builder<GUnminimizeCommentInput, GUnminimizeCommentInputBuilder> {
  _$GUnminimizeCommentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _subjectId;
  String? get subjectId => _$this._subjectId;
  set subjectId(String? subjectId) => _$this._subjectId = subjectId;

  GUnminimizeCommentInputBuilder();

  GUnminimizeCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _subjectId = $v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnminimizeCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnminimizeCommentInput;
  }

  @override
  void update(void Function(GUnminimizeCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnminimizeCommentInput build() {
    final _$result = _$v ??
        new _$GUnminimizeCommentInput._(
            clientMutationId: clientMutationId,
            subjectId: BuiltValueNullFieldError.checkNotNull(
                subjectId, 'GUnminimizeCommentInput', 'subjectId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnpinIssueInput extends GUnpinIssueInput {
  @override
  final String? clientMutationId;
  @override
  final String issueId;

  factory _$GUnpinIssueInput(
          [void Function(GUnpinIssueInputBuilder)? updates]) =>
      (new GUnpinIssueInputBuilder()..update(updates)).build();

  _$GUnpinIssueInput._({this.clientMutationId, required this.issueId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        issueId, 'GUnpinIssueInput', 'issueId');
  }

  @override
  GUnpinIssueInput rebuild(void Function(GUnpinIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnpinIssueInputBuilder toBuilder() =>
      new GUnpinIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnpinIssueInput &&
        clientMutationId == other.clientMutationId &&
        issueId == other.issueId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), issueId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnpinIssueInput')
          ..add('clientMutationId', clientMutationId)
          ..add('issueId', issueId))
        .toString();
  }
}

class GUnpinIssueInputBuilder
    implements Builder<GUnpinIssueInput, GUnpinIssueInputBuilder> {
  _$GUnpinIssueInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _issueId;
  String? get issueId => _$this._issueId;
  set issueId(String? issueId) => _$this._issueId = issueId;

  GUnpinIssueInputBuilder();

  GUnpinIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _issueId = $v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnpinIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnpinIssueInput;
  }

  @override
  void update(void Function(GUnpinIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnpinIssueInput build() {
    final _$result = _$v ??
        new _$GUnpinIssueInput._(
            clientMutationId: clientMutationId,
            issueId: BuiltValueNullFieldError.checkNotNull(
                issueId, 'GUnpinIssueInput', 'issueId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUnresolveReviewThreadInput extends GUnresolveReviewThreadInput {
  @override
  final String? clientMutationId;
  @override
  final String threadId;

  factory _$GUnresolveReviewThreadInput(
          [void Function(GUnresolveReviewThreadInputBuilder)? updates]) =>
      (new GUnresolveReviewThreadInputBuilder()..update(updates)).build();

  _$GUnresolveReviewThreadInput._(
      {this.clientMutationId, required this.threadId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        threadId, 'GUnresolveReviewThreadInput', 'threadId');
  }

  @override
  GUnresolveReviewThreadInput rebuild(
          void Function(GUnresolveReviewThreadInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUnresolveReviewThreadInputBuilder toBuilder() =>
      new GUnresolveReviewThreadInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUnresolveReviewThreadInput &&
        clientMutationId == other.clientMutationId &&
        threadId == other.threadId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), threadId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUnresolveReviewThreadInput')
          ..add('clientMutationId', clientMutationId)
          ..add('threadId', threadId))
        .toString();
  }
}

class GUnresolveReviewThreadInputBuilder
    implements
        Builder<GUnresolveReviewThreadInput,
            GUnresolveReviewThreadInputBuilder> {
  _$GUnresolveReviewThreadInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _threadId;
  String? get threadId => _$this._threadId;
  set threadId(String? threadId) => _$this._threadId = threadId;

  GUnresolveReviewThreadInputBuilder();

  GUnresolveReviewThreadInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _threadId = $v.threadId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnresolveReviewThreadInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUnresolveReviewThreadInput;
  }

  @override
  void update(void Function(GUnresolveReviewThreadInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUnresolveReviewThreadInput build() {
    final _$result = _$v ??
        new _$GUnresolveReviewThreadInput._(
            clientMutationId: clientMutationId,
            threadId: BuiltValueNullFieldError.checkNotNull(
                threadId, 'GUnresolveReviewThreadInput', 'threadId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateBranchProtectionRuleInput
    extends GUpdateBranchProtectionRuleInput {
  @override
  final bool? allowsDeletions;
  @override
  final bool? allowsForcePushes;
  @override
  final String branchProtectionRuleId;
  @override
  final String? clientMutationId;
  @override
  final bool? dismissesStaleReviews;
  @override
  final bool? isAdminEnforced;
  @override
  final String? pattern;
  @override
  final BuiltList<String>? pushActorIds;
  @override
  final int? requiredApprovingReviewCount;
  @override
  final BuiltList<String>? requiredStatusCheckContexts;
  @override
  final bool? requiresApprovingReviews;
  @override
  final bool? requiresCodeOwnerReviews;
  @override
  final bool? requiresCommitSignatures;
  @override
  final bool? requiresLinearHistory;
  @override
  final bool? requiresStatusChecks;
  @override
  final bool? requiresStrictStatusChecks;
  @override
  final bool? restrictsPushes;
  @override
  final bool? restrictsReviewDismissals;
  @override
  final BuiltList<String>? reviewDismissalActorIds;

  factory _$GUpdateBranchProtectionRuleInput(
          [void Function(GUpdateBranchProtectionRuleInputBuilder)? updates]) =>
      (new GUpdateBranchProtectionRuleInputBuilder()..update(updates)).build();

  _$GUpdateBranchProtectionRuleInput._(
      {this.allowsDeletions,
      this.allowsForcePushes,
      required this.branchProtectionRuleId,
      this.clientMutationId,
      this.dismissesStaleReviews,
      this.isAdminEnforced,
      this.pattern,
      this.pushActorIds,
      this.requiredApprovingReviewCount,
      this.requiredStatusCheckContexts,
      this.requiresApprovingReviews,
      this.requiresCodeOwnerReviews,
      this.requiresCommitSignatures,
      this.requiresLinearHistory,
      this.requiresStatusChecks,
      this.requiresStrictStatusChecks,
      this.restrictsPushes,
      this.restrictsReviewDismissals,
      this.reviewDismissalActorIds})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(branchProtectionRuleId,
        'GUpdateBranchProtectionRuleInput', 'branchProtectionRuleId');
  }

  @override
  GUpdateBranchProtectionRuleInput rebuild(
          void Function(GUpdateBranchProtectionRuleInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateBranchProtectionRuleInputBuilder toBuilder() =>
      new GUpdateBranchProtectionRuleInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateBranchProtectionRuleInput &&
        allowsDeletions == other.allowsDeletions &&
        allowsForcePushes == other.allowsForcePushes &&
        branchProtectionRuleId == other.branchProtectionRuleId &&
        clientMutationId == other.clientMutationId &&
        dismissesStaleReviews == other.dismissesStaleReviews &&
        isAdminEnforced == other.isAdminEnforced &&
        pattern == other.pattern &&
        pushActorIds == other.pushActorIds &&
        requiredApprovingReviewCount == other.requiredApprovingReviewCount &&
        requiredStatusCheckContexts == other.requiredStatusCheckContexts &&
        requiresApprovingReviews == other.requiresApprovingReviews &&
        requiresCodeOwnerReviews == other.requiresCodeOwnerReviews &&
        requiresCommitSignatures == other.requiresCommitSignatures &&
        requiresLinearHistory == other.requiresLinearHistory &&
        requiresStatusChecks == other.requiresStatusChecks &&
        requiresStrictStatusChecks == other.requiresStrictStatusChecks &&
        restrictsPushes == other.restrictsPushes &&
        restrictsReviewDismissals == other.restrictsReviewDismissals &&
        reviewDismissalActorIds == other.reviewDismissalActorIds;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc(
                                    $jc(
                                        $jc(
                                            $jc(
                                                $jc(
                                                    $jc(
                                                        $jc(
                                                            $jc(
                                                                $jc(
                                                                    $jc(
                                                                        $jc(
                                                                            $jc(
                                                                                0,
                                                                                allowsDeletions
                                                                                    .hashCode),
                                                                            allowsForcePushes
                                                                                .hashCode),
                                                                        branchProtectionRuleId
                                                                            .hashCode),
                                                                    clientMutationId
                                                                        .hashCode),
                                                                dismissesStaleReviews
                                                                    .hashCode),
                                                            isAdminEnforced
                                                                .hashCode),
                                                        pattern.hashCode),
                                                    pushActorIds.hashCode),
                                                requiredApprovingReviewCount
                                                    .hashCode),
                                            requiredStatusCheckContexts
                                                .hashCode),
                                        requiresApprovingReviews.hashCode),
                                    requiresCodeOwnerReviews.hashCode),
                                requiresCommitSignatures.hashCode),
                            requiresLinearHistory.hashCode),
                        requiresStatusChecks.hashCode),
                    requiresStrictStatusChecks.hashCode),
                restrictsPushes.hashCode),
            restrictsReviewDismissals.hashCode),
        reviewDismissalActorIds.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateBranchProtectionRuleInput')
          ..add('allowsDeletions', allowsDeletions)
          ..add('allowsForcePushes', allowsForcePushes)
          ..add('branchProtectionRuleId', branchProtectionRuleId)
          ..add('clientMutationId', clientMutationId)
          ..add('dismissesStaleReviews', dismissesStaleReviews)
          ..add('isAdminEnforced', isAdminEnforced)
          ..add('pattern', pattern)
          ..add('pushActorIds', pushActorIds)
          ..add('requiredApprovingReviewCount', requiredApprovingReviewCount)
          ..add('requiredStatusCheckContexts', requiredStatusCheckContexts)
          ..add('requiresApprovingReviews', requiresApprovingReviews)
          ..add('requiresCodeOwnerReviews', requiresCodeOwnerReviews)
          ..add('requiresCommitSignatures', requiresCommitSignatures)
          ..add('requiresLinearHistory', requiresLinearHistory)
          ..add('requiresStatusChecks', requiresStatusChecks)
          ..add('requiresStrictStatusChecks', requiresStrictStatusChecks)
          ..add('restrictsPushes', restrictsPushes)
          ..add('restrictsReviewDismissals', restrictsReviewDismissals)
          ..add('reviewDismissalActorIds', reviewDismissalActorIds))
        .toString();
  }
}

class GUpdateBranchProtectionRuleInputBuilder
    implements
        Builder<GUpdateBranchProtectionRuleInput,
            GUpdateBranchProtectionRuleInputBuilder> {
  _$GUpdateBranchProtectionRuleInput? _$v;

  bool? _allowsDeletions;
  bool? get allowsDeletions => _$this._allowsDeletions;
  set allowsDeletions(bool? allowsDeletions) =>
      _$this._allowsDeletions = allowsDeletions;

  bool? _allowsForcePushes;
  bool? get allowsForcePushes => _$this._allowsForcePushes;
  set allowsForcePushes(bool? allowsForcePushes) =>
      _$this._allowsForcePushes = allowsForcePushes;

  String? _branchProtectionRuleId;
  String? get branchProtectionRuleId => _$this._branchProtectionRuleId;
  set branchProtectionRuleId(String? branchProtectionRuleId) =>
      _$this._branchProtectionRuleId = branchProtectionRuleId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _dismissesStaleReviews;
  bool? get dismissesStaleReviews => _$this._dismissesStaleReviews;
  set dismissesStaleReviews(bool? dismissesStaleReviews) =>
      _$this._dismissesStaleReviews = dismissesStaleReviews;

  bool? _isAdminEnforced;
  bool? get isAdminEnforced => _$this._isAdminEnforced;
  set isAdminEnforced(bool? isAdminEnforced) =>
      _$this._isAdminEnforced = isAdminEnforced;

  String? _pattern;
  String? get pattern => _$this._pattern;
  set pattern(String? pattern) => _$this._pattern = pattern;

  ListBuilder<String>? _pushActorIds;
  ListBuilder<String> get pushActorIds =>
      _$this._pushActorIds ??= new ListBuilder<String>();
  set pushActorIds(ListBuilder<String>? pushActorIds) =>
      _$this._pushActorIds = pushActorIds;

  int? _requiredApprovingReviewCount;
  int? get requiredApprovingReviewCount => _$this._requiredApprovingReviewCount;
  set requiredApprovingReviewCount(int? requiredApprovingReviewCount) =>
      _$this._requiredApprovingReviewCount = requiredApprovingReviewCount;

  ListBuilder<String>? _requiredStatusCheckContexts;
  ListBuilder<String> get requiredStatusCheckContexts =>
      _$this._requiredStatusCheckContexts ??= new ListBuilder<String>();
  set requiredStatusCheckContexts(
          ListBuilder<String>? requiredStatusCheckContexts) =>
      _$this._requiredStatusCheckContexts = requiredStatusCheckContexts;

  bool? _requiresApprovingReviews;
  bool? get requiresApprovingReviews => _$this._requiresApprovingReviews;
  set requiresApprovingReviews(bool? requiresApprovingReviews) =>
      _$this._requiresApprovingReviews = requiresApprovingReviews;

  bool? _requiresCodeOwnerReviews;
  bool? get requiresCodeOwnerReviews => _$this._requiresCodeOwnerReviews;
  set requiresCodeOwnerReviews(bool? requiresCodeOwnerReviews) =>
      _$this._requiresCodeOwnerReviews = requiresCodeOwnerReviews;

  bool? _requiresCommitSignatures;
  bool? get requiresCommitSignatures => _$this._requiresCommitSignatures;
  set requiresCommitSignatures(bool? requiresCommitSignatures) =>
      _$this._requiresCommitSignatures = requiresCommitSignatures;

  bool? _requiresLinearHistory;
  bool? get requiresLinearHistory => _$this._requiresLinearHistory;
  set requiresLinearHistory(bool? requiresLinearHistory) =>
      _$this._requiresLinearHistory = requiresLinearHistory;

  bool? _requiresStatusChecks;
  bool? get requiresStatusChecks => _$this._requiresStatusChecks;
  set requiresStatusChecks(bool? requiresStatusChecks) =>
      _$this._requiresStatusChecks = requiresStatusChecks;

  bool? _requiresStrictStatusChecks;
  bool? get requiresStrictStatusChecks => _$this._requiresStrictStatusChecks;
  set requiresStrictStatusChecks(bool? requiresStrictStatusChecks) =>
      _$this._requiresStrictStatusChecks = requiresStrictStatusChecks;

  bool? _restrictsPushes;
  bool? get restrictsPushes => _$this._restrictsPushes;
  set restrictsPushes(bool? restrictsPushes) =>
      _$this._restrictsPushes = restrictsPushes;

  bool? _restrictsReviewDismissals;
  bool? get restrictsReviewDismissals => _$this._restrictsReviewDismissals;
  set restrictsReviewDismissals(bool? restrictsReviewDismissals) =>
      _$this._restrictsReviewDismissals = restrictsReviewDismissals;

  ListBuilder<String>? _reviewDismissalActorIds;
  ListBuilder<String> get reviewDismissalActorIds =>
      _$this._reviewDismissalActorIds ??= new ListBuilder<String>();
  set reviewDismissalActorIds(ListBuilder<String>? reviewDismissalActorIds) =>
      _$this._reviewDismissalActorIds = reviewDismissalActorIds;

  GUpdateBranchProtectionRuleInputBuilder();

  GUpdateBranchProtectionRuleInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _allowsDeletions = $v.allowsDeletions;
      _allowsForcePushes = $v.allowsForcePushes;
      _branchProtectionRuleId = $v.branchProtectionRuleId;
      _clientMutationId = $v.clientMutationId;
      _dismissesStaleReviews = $v.dismissesStaleReviews;
      _isAdminEnforced = $v.isAdminEnforced;
      _pattern = $v.pattern;
      _pushActorIds = $v.pushActorIds?.toBuilder();
      _requiredApprovingReviewCount = $v.requiredApprovingReviewCount;
      _requiredStatusCheckContexts =
          $v.requiredStatusCheckContexts?.toBuilder();
      _requiresApprovingReviews = $v.requiresApprovingReviews;
      _requiresCodeOwnerReviews = $v.requiresCodeOwnerReviews;
      _requiresCommitSignatures = $v.requiresCommitSignatures;
      _requiresLinearHistory = $v.requiresLinearHistory;
      _requiresStatusChecks = $v.requiresStatusChecks;
      _requiresStrictStatusChecks = $v.requiresStrictStatusChecks;
      _restrictsPushes = $v.restrictsPushes;
      _restrictsReviewDismissals = $v.restrictsReviewDismissals;
      _reviewDismissalActorIds = $v.reviewDismissalActorIds?.toBuilder();
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateBranchProtectionRuleInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateBranchProtectionRuleInput;
  }

  @override
  void update(void Function(GUpdateBranchProtectionRuleInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateBranchProtectionRuleInput build() {
    _$GUpdateBranchProtectionRuleInput _$result;
    try {
      _$result = _$v ??
          new _$GUpdateBranchProtectionRuleInput._(
              allowsDeletions: allowsDeletions,
              allowsForcePushes: allowsForcePushes,
              branchProtectionRuleId: BuiltValueNullFieldError.checkNotNull(
                  branchProtectionRuleId,
                  'GUpdateBranchProtectionRuleInput',
                  'branchProtectionRuleId'),
              clientMutationId: clientMutationId,
              dismissesStaleReviews: dismissesStaleReviews,
              isAdminEnforced: isAdminEnforced,
              pattern: pattern,
              pushActorIds: _pushActorIds?.build(),
              requiredApprovingReviewCount: requiredApprovingReviewCount,
              requiredStatusCheckContexts:
                  _requiredStatusCheckContexts?.build(),
              requiresApprovingReviews: requiresApprovingReviews,
              requiresCodeOwnerReviews: requiresCodeOwnerReviews,
              requiresCommitSignatures: requiresCommitSignatures,
              requiresLinearHistory: requiresLinearHistory,
              requiresStatusChecks: requiresStatusChecks,
              requiresStrictStatusChecks: requiresStrictStatusChecks,
              restrictsPushes: restrictsPushes,
              restrictsReviewDismissals: restrictsReviewDismissals,
              reviewDismissalActorIds: _reviewDismissalActorIds?.build());
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'pushActorIds';
        _pushActorIds?.build();

        _$failedField = 'requiredStatusCheckContexts';
        _requiredStatusCheckContexts?.build();

        _$failedField = 'reviewDismissalActorIds';
        _reviewDismissalActorIds?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdateBranchProtectionRuleInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateCheckRunInput extends GUpdateCheckRunInput {
  @override
  final BuiltList<GCheckRunAction>? actions;
  @override
  final String checkRunId;
  @override
  final String? clientMutationId;
  @override
  final DateTime? completedAt;
  @override
  final GCheckConclusionState? conclusion;
  @override
  final String? detailsUrl;
  @override
  final String? externalId;
  @override
  final String? name;
  @override
  final GCheckRunOutput? output;
  @override
  final String repositoryId;
  @override
  final DateTime? startedAt;
  @override
  final GRequestableCheckStatusState? status;

  factory _$GUpdateCheckRunInput(
          [void Function(GUpdateCheckRunInputBuilder)? updates]) =>
      (new GUpdateCheckRunInputBuilder()..update(updates)).build();

  _$GUpdateCheckRunInput._(
      {this.actions,
      required this.checkRunId,
      this.clientMutationId,
      this.completedAt,
      this.conclusion,
      this.detailsUrl,
      this.externalId,
      this.name,
      this.output,
      required this.repositoryId,
      this.startedAt,
      this.status})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        checkRunId, 'GUpdateCheckRunInput', 'checkRunId');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GUpdateCheckRunInput', 'repositoryId');
  }

  @override
  GUpdateCheckRunInput rebuild(
          void Function(GUpdateCheckRunInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateCheckRunInputBuilder toBuilder() =>
      new GUpdateCheckRunInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateCheckRunInput &&
        actions == other.actions &&
        checkRunId == other.checkRunId &&
        clientMutationId == other.clientMutationId &&
        completedAt == other.completedAt &&
        conclusion == other.conclusion &&
        detailsUrl == other.detailsUrl &&
        externalId == other.externalId &&
        name == other.name &&
        output == other.output &&
        repositoryId == other.repositoryId &&
        startedAt == other.startedAt &&
        status == other.status;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc(
                                    $jc(
                                        $jc(
                                            $jc($jc(0, actions.hashCode),
                                                checkRunId.hashCode),
                                            clientMutationId.hashCode),
                                        completedAt.hashCode),
                                    conclusion.hashCode),
                                detailsUrl.hashCode),
                            externalId.hashCode),
                        name.hashCode),
                    output.hashCode),
                repositoryId.hashCode),
            startedAt.hashCode),
        status.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateCheckRunInput')
          ..add('actions', actions)
          ..add('checkRunId', checkRunId)
          ..add('clientMutationId', clientMutationId)
          ..add('completedAt', completedAt)
          ..add('conclusion', conclusion)
          ..add('detailsUrl', detailsUrl)
          ..add('externalId', externalId)
          ..add('name', name)
          ..add('output', output)
          ..add('repositoryId', repositoryId)
          ..add('startedAt', startedAt)
          ..add('status', status))
        .toString();
  }
}

class GUpdateCheckRunInputBuilder
    implements Builder<GUpdateCheckRunInput, GUpdateCheckRunInputBuilder> {
  _$GUpdateCheckRunInput? _$v;

  ListBuilder<GCheckRunAction>? _actions;
  ListBuilder<GCheckRunAction> get actions =>
      _$this._actions ??= new ListBuilder<GCheckRunAction>();
  set actions(ListBuilder<GCheckRunAction>? actions) =>
      _$this._actions = actions;

  String? _checkRunId;
  String? get checkRunId => _$this._checkRunId;
  set checkRunId(String? checkRunId) => _$this._checkRunId = checkRunId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  DateTime? _completedAt;
  DateTime? get completedAt => _$this._completedAt;
  set completedAt(DateTime? completedAt) => _$this._completedAt = completedAt;

  GCheckConclusionState? _conclusion;
  GCheckConclusionState? get conclusion => _$this._conclusion;
  set conclusion(GCheckConclusionState? conclusion) =>
      _$this._conclusion = conclusion;

  String? _detailsUrl;
  String? get detailsUrl => _$this._detailsUrl;
  set detailsUrl(String? detailsUrl) => _$this._detailsUrl = detailsUrl;

  String? _externalId;
  String? get externalId => _$this._externalId;
  set externalId(String? externalId) => _$this._externalId = externalId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  GCheckRunOutputBuilder? _output;
  GCheckRunOutputBuilder get output =>
      _$this._output ??= new GCheckRunOutputBuilder();
  set output(GCheckRunOutputBuilder? output) => _$this._output = output;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  DateTime? _startedAt;
  DateTime? get startedAt => _$this._startedAt;
  set startedAt(DateTime? startedAt) => _$this._startedAt = startedAt;

  GRequestableCheckStatusState? _status;
  GRequestableCheckStatusState? get status => _$this._status;
  set status(GRequestableCheckStatusState? status) => _$this._status = status;

  GUpdateCheckRunInputBuilder();

  GUpdateCheckRunInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _actions = $v.actions?.toBuilder();
      _checkRunId = $v.checkRunId;
      _clientMutationId = $v.clientMutationId;
      _completedAt = $v.completedAt;
      _conclusion = $v.conclusion;
      _detailsUrl = $v.detailsUrl;
      _externalId = $v.externalId;
      _name = $v.name;
      _output = $v.output?.toBuilder();
      _repositoryId = $v.repositoryId;
      _startedAt = $v.startedAt;
      _status = $v.status;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateCheckRunInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateCheckRunInput;
  }

  @override
  void update(void Function(GUpdateCheckRunInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateCheckRunInput build() {
    _$GUpdateCheckRunInput _$result;
    try {
      _$result = _$v ??
          new _$GUpdateCheckRunInput._(
              actions: _actions?.build(),
              checkRunId: BuiltValueNullFieldError.checkNotNull(
                  checkRunId, 'GUpdateCheckRunInput', 'checkRunId'),
              clientMutationId: clientMutationId,
              completedAt: completedAt,
              conclusion: conclusion,
              detailsUrl: detailsUrl,
              externalId: externalId,
              name: name,
              output: _output?.build(),
              repositoryId: BuiltValueNullFieldError.checkNotNull(
                  repositoryId, 'GUpdateCheckRunInput', 'repositoryId'),
              startedAt: startedAt,
              status: status);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'actions';
        _actions?.build();

        _$failedField = 'output';
        _output?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdateCheckRunInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateCheckSuitePreferencesInput
    extends GUpdateCheckSuitePreferencesInput {
  @override
  final BuiltList<GCheckSuiteAutoTriggerPreference> autoTriggerPreferences;
  @override
  final String? clientMutationId;
  @override
  final String repositoryId;

  factory _$GUpdateCheckSuitePreferencesInput(
          [void Function(GUpdateCheckSuitePreferencesInputBuilder)? updates]) =>
      (new GUpdateCheckSuitePreferencesInputBuilder()..update(updates)).build();

  _$GUpdateCheckSuitePreferencesInput._(
      {required this.autoTriggerPreferences,
      this.clientMutationId,
      required this.repositoryId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(autoTriggerPreferences,
        'GUpdateCheckSuitePreferencesInput', 'autoTriggerPreferences');
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GUpdateCheckSuitePreferencesInput', 'repositoryId');
  }

  @override
  GUpdateCheckSuitePreferencesInput rebuild(
          void Function(GUpdateCheckSuitePreferencesInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateCheckSuitePreferencesInputBuilder toBuilder() =>
      new GUpdateCheckSuitePreferencesInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateCheckSuitePreferencesInput &&
        autoTriggerPreferences == other.autoTriggerPreferences &&
        clientMutationId == other.clientMutationId &&
        repositoryId == other.repositoryId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, autoTriggerPreferences.hashCode), clientMutationId.hashCode),
        repositoryId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateCheckSuitePreferencesInput')
          ..add('autoTriggerPreferences', autoTriggerPreferences)
          ..add('clientMutationId', clientMutationId)
          ..add('repositoryId', repositoryId))
        .toString();
  }
}

class GUpdateCheckSuitePreferencesInputBuilder
    implements
        Builder<GUpdateCheckSuitePreferencesInput,
            GUpdateCheckSuitePreferencesInputBuilder> {
  _$GUpdateCheckSuitePreferencesInput? _$v;

  ListBuilder<GCheckSuiteAutoTriggerPreference>? _autoTriggerPreferences;
  ListBuilder<GCheckSuiteAutoTriggerPreference> get autoTriggerPreferences =>
      _$this._autoTriggerPreferences ??=
          new ListBuilder<GCheckSuiteAutoTriggerPreference>();
  set autoTriggerPreferences(
          ListBuilder<GCheckSuiteAutoTriggerPreference>?
              autoTriggerPreferences) =>
      _$this._autoTriggerPreferences = autoTriggerPreferences;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  GUpdateCheckSuitePreferencesInputBuilder();

  GUpdateCheckSuitePreferencesInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _autoTriggerPreferences = $v.autoTriggerPreferences.toBuilder();
      _clientMutationId = $v.clientMutationId;
      _repositoryId = $v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateCheckSuitePreferencesInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateCheckSuitePreferencesInput;
  }

  @override
  void update(
      void Function(GUpdateCheckSuitePreferencesInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateCheckSuitePreferencesInput build() {
    _$GUpdateCheckSuitePreferencesInput _$result;
    try {
      _$result = _$v ??
          new _$GUpdateCheckSuitePreferencesInput._(
              autoTriggerPreferences: autoTriggerPreferences.build(),
              clientMutationId: clientMutationId,
              repositoryId: BuiltValueNullFieldError.checkNotNull(repositoryId,
                  'GUpdateCheckSuitePreferencesInput', 'repositoryId'));
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'autoTriggerPreferences';
        autoTriggerPreferences.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdateCheckSuitePreferencesInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateDiscussionCommentInput extends GUpdateDiscussionCommentInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String commentId;

  factory _$GUpdateDiscussionCommentInput(
          [void Function(GUpdateDiscussionCommentInputBuilder)? updates]) =>
      (new GUpdateDiscussionCommentInputBuilder()..update(updates)).build();

  _$GUpdateDiscussionCommentInput._(
      {required this.body, this.clientMutationId, required this.commentId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GUpdateDiscussionCommentInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        commentId, 'GUpdateDiscussionCommentInput', 'commentId');
  }

  @override
  GUpdateDiscussionCommentInput rebuild(
          void Function(GUpdateDiscussionCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateDiscussionCommentInputBuilder toBuilder() =>
      new GUpdateDiscussionCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateDiscussionCommentInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        commentId == other.commentId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
        commentId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateDiscussionCommentInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('commentId', commentId))
        .toString();
  }
}

class GUpdateDiscussionCommentInputBuilder
    implements
        Builder<GUpdateDiscussionCommentInput,
            GUpdateDiscussionCommentInputBuilder> {
  _$GUpdateDiscussionCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _commentId;
  String? get commentId => _$this._commentId;
  set commentId(String? commentId) => _$this._commentId = commentId;

  GUpdateDiscussionCommentInputBuilder();

  GUpdateDiscussionCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _commentId = $v.commentId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateDiscussionCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateDiscussionCommentInput;
  }

  @override
  void update(void Function(GUpdateDiscussionCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateDiscussionCommentInput build() {
    final _$result = _$v ??
        new _$GUpdateDiscussionCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GUpdateDiscussionCommentInput', 'body'),
            clientMutationId: clientMutationId,
            commentId: BuiltValueNullFieldError.checkNotNull(
                commentId, 'GUpdateDiscussionCommentInput', 'commentId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateDiscussionInput extends GUpdateDiscussionInput {
  @override
  final String? body;
  @override
  final String? categoryId;
  @override
  final String? clientMutationId;
  @override
  final String discussionId;
  @override
  final String? title;

  factory _$GUpdateDiscussionInput(
          [void Function(GUpdateDiscussionInputBuilder)? updates]) =>
      (new GUpdateDiscussionInputBuilder()..update(updates)).build();

  _$GUpdateDiscussionInput._(
      {this.body,
      this.categoryId,
      this.clientMutationId,
      required this.discussionId,
      this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        discussionId, 'GUpdateDiscussionInput', 'discussionId');
  }

  @override
  GUpdateDiscussionInput rebuild(
          void Function(GUpdateDiscussionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateDiscussionInputBuilder toBuilder() =>
      new GUpdateDiscussionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateDiscussionInput &&
        body == other.body &&
        categoryId == other.categoryId &&
        clientMutationId == other.clientMutationId &&
        discussionId == other.discussionId &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, body.hashCode), categoryId.hashCode),
                clientMutationId.hashCode),
            discussionId.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateDiscussionInput')
          ..add('body', body)
          ..add('categoryId', categoryId)
          ..add('clientMutationId', clientMutationId)
          ..add('discussionId', discussionId)
          ..add('title', title))
        .toString();
  }
}

class GUpdateDiscussionInputBuilder
    implements Builder<GUpdateDiscussionInput, GUpdateDiscussionInputBuilder> {
  _$GUpdateDiscussionInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _categoryId;
  String? get categoryId => _$this._categoryId;
  set categoryId(String? categoryId) => _$this._categoryId = categoryId;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _discussionId;
  String? get discussionId => _$this._discussionId;
  set discussionId(String? discussionId) => _$this._discussionId = discussionId;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GUpdateDiscussionInputBuilder();

  GUpdateDiscussionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _categoryId = $v.categoryId;
      _clientMutationId = $v.clientMutationId;
      _discussionId = $v.discussionId;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateDiscussionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateDiscussionInput;
  }

  @override
  void update(void Function(GUpdateDiscussionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateDiscussionInput build() {
    final _$result = _$v ??
        new _$GUpdateDiscussionInput._(
            body: body,
            categoryId: categoryId,
            clientMutationId: clientMutationId,
            discussionId: BuiltValueNullFieldError.checkNotNull(
                discussionId, 'GUpdateDiscussionInput', 'discussionId'),
            title: title);
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseAdministratorRoleInput
    extends GUpdateEnterpriseAdministratorRoleInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final String login;
  @override
  final GEnterpriseAdministratorRole role;

  factory _$GUpdateEnterpriseAdministratorRoleInput(
          [void Function(GUpdateEnterpriseAdministratorRoleInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseAdministratorRoleInputBuilder()..update(updates))
          .build();

  _$GUpdateEnterpriseAdministratorRoleInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.login,
      required this.role})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(enterpriseId,
        'GUpdateEnterpriseAdministratorRoleInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        login, 'GUpdateEnterpriseAdministratorRoleInput', 'login');
    BuiltValueNullFieldError.checkNotNull(
        role, 'GUpdateEnterpriseAdministratorRoleInput', 'role');
  }

  @override
  GUpdateEnterpriseAdministratorRoleInput rebuild(
          void Function(GUpdateEnterpriseAdministratorRoleInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseAdministratorRoleInputBuilder toBuilder() =>
      new GUpdateEnterpriseAdministratorRoleInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseAdministratorRoleInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        login == other.login &&
        role == other.role;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
            login.hashCode),
        role.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseAdministratorRoleInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('login', login)
          ..add('role', role))
        .toString();
  }
}

class GUpdateEnterpriseAdministratorRoleInputBuilder
    implements
        Builder<GUpdateEnterpriseAdministratorRoleInput,
            GUpdateEnterpriseAdministratorRoleInputBuilder> {
  _$GUpdateEnterpriseAdministratorRoleInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _login;
  String? get login => _$this._login;
  set login(String? login) => _$this._login = login;

  GEnterpriseAdministratorRole? _role;
  GEnterpriseAdministratorRole? get role => _$this._role;
  set role(GEnterpriseAdministratorRole? role) => _$this._role = role;

  GUpdateEnterpriseAdministratorRoleInputBuilder();

  GUpdateEnterpriseAdministratorRoleInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _login = $v.login;
      _role = $v.role;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseAdministratorRoleInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseAdministratorRoleInput;
  }

  @override
  void update(
      void Function(GUpdateEnterpriseAdministratorRoleInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseAdministratorRoleInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseAdministratorRoleInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                'GUpdateEnterpriseAdministratorRoleInput', 'enterpriseId'),
            login: BuiltValueNullFieldError.checkNotNull(
                login, 'GUpdateEnterpriseAdministratorRoleInput', 'login'),
            role: BuiltValueNullFieldError.checkNotNull(
                role, 'GUpdateEnterpriseAdministratorRoleInput', 'role'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput
    extends GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput(
          [void Function(
                  GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other
            is GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput,
            GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder> {
  _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder();

  GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput
    extends GUpdateEnterpriseDefaultRepositoryPermissionSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseDefaultRepositoryPermissionSettingValue settingValue;

  factory _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput(
          [void Function(
                  GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseDefaultRepositoryPermissionSettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseDefaultRepositoryPermissionSettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseDefaultRepositoryPermissionSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder toBuilder() =>
      new GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder()
        ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseDefaultRepositoryPermissionSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseDefaultRepositoryPermissionSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseDefaultRepositoryPermissionSettingInput,
            GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder> {
  _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseDefaultRepositoryPermissionSettingValue? _settingValue;
  GEnterpriseDefaultRepositoryPermissionSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(
          GEnterpriseDefaultRepositoryPermissionSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder();

  GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseDefaultRepositoryPermissionSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseDefaultRepositoryPermissionSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseDefaultRepositoryPermissionSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseDefaultRepositoryPermissionSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseDefaultRepositoryPermissionSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput
    extends GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other
            is GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder
    implements
        Builder<
            GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput,
            GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder();

  GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder
      get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other
        as _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput
                ._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput
    extends GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final bool? membersCanCreateInternalRepositories;
  @override
  final bool? membersCanCreatePrivateRepositories;
  @override
  final bool? membersCanCreatePublicRepositories;
  @override
  final bool? membersCanCreateRepositoriesPolicyEnabled;
  @override
  final GEnterpriseMembersCanCreateRepositoriesSettingValue? settingValue;

  factory _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      this.membersCanCreateInternalRepositories,
      this.membersCanCreatePrivateRepositories,
      this.membersCanCreatePublicRepositories,
      this.membersCanCreateRepositoriesPolicyEnabled,
      this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput',
        'enterpriseId');
  }

  @override
  GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        membersCanCreateInternalRepositories ==
            other.membersCanCreateInternalRepositories &&
        membersCanCreatePrivateRepositories ==
            other.membersCanCreatePrivateRepositories &&
        membersCanCreatePublicRepositories ==
            other.membersCanCreatePublicRepositories &&
        membersCanCreateRepositoriesPolicyEnabled ==
            other.membersCanCreateRepositoriesPolicyEnabled &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc($jc(0, clientMutationId.hashCode),
                            enterpriseId.hashCode),
                        membersCanCreateInternalRepositories.hashCode),
                    membersCanCreatePrivateRepositories.hashCode),
                membersCanCreatePublicRepositories.hashCode),
            membersCanCreateRepositoriesPolicyEnabled.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('membersCanCreateInternalRepositories',
              membersCanCreateInternalRepositories)
          ..add('membersCanCreatePrivateRepositories',
              membersCanCreatePrivateRepositories)
          ..add('membersCanCreatePublicRepositories',
              membersCanCreatePublicRepositories)
          ..add('membersCanCreateRepositoriesPolicyEnabled',
              membersCanCreateRepositoriesPolicyEnabled)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput,
            GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  bool? _membersCanCreateInternalRepositories;
  bool? get membersCanCreateInternalRepositories =>
      _$this._membersCanCreateInternalRepositories;
  set membersCanCreateInternalRepositories(
          bool? membersCanCreateInternalRepositories) =>
      _$this._membersCanCreateInternalRepositories =
          membersCanCreateInternalRepositories;

  bool? _membersCanCreatePrivateRepositories;
  bool? get membersCanCreatePrivateRepositories =>
      _$this._membersCanCreatePrivateRepositories;
  set membersCanCreatePrivateRepositories(
          bool? membersCanCreatePrivateRepositories) =>
      _$this._membersCanCreatePrivateRepositories =
          membersCanCreatePrivateRepositories;

  bool? _membersCanCreatePublicRepositories;
  bool? get membersCanCreatePublicRepositories =>
      _$this._membersCanCreatePublicRepositories;
  set membersCanCreatePublicRepositories(
          bool? membersCanCreatePublicRepositories) =>
      _$this._membersCanCreatePublicRepositories =
          membersCanCreatePublicRepositories;

  bool? _membersCanCreateRepositoriesPolicyEnabled;
  bool? get membersCanCreateRepositoriesPolicyEnabled =>
      _$this._membersCanCreateRepositoriesPolicyEnabled;
  set membersCanCreateRepositoriesPolicyEnabled(
          bool? membersCanCreateRepositoriesPolicyEnabled) =>
      _$this._membersCanCreateRepositoriesPolicyEnabled =
          membersCanCreateRepositoriesPolicyEnabled;

  GEnterpriseMembersCanCreateRepositoriesSettingValue? _settingValue;
  GEnterpriseMembersCanCreateRepositoriesSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(
          GEnterpriseMembersCanCreateRepositoriesSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder();

  GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _membersCanCreateInternalRepositories =
          $v.membersCanCreateInternalRepositories;
      _membersCanCreatePrivateRepositories =
          $v.membersCanCreatePrivateRepositories;
      _membersCanCreatePublicRepositories =
          $v.membersCanCreatePublicRepositories;
      _membersCanCreateRepositoriesPolicyEnabled =
          $v.membersCanCreateRepositoriesPolicyEnabled;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseMembersCanCreateRepositoriesSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanCreateRepositoriesSettingInput',
                'enterpriseId'),
            membersCanCreateInternalRepositories:
                membersCanCreateInternalRepositories,
            membersCanCreatePrivateRepositories:
                membersCanCreatePrivateRepositories,
            membersCanCreatePublicRepositories:
                membersCanCreatePublicRepositories,
            membersCanCreateRepositoriesPolicyEnabled:
                membersCanCreateRepositoriesPolicyEnabled,
            settingValue: settingValue);
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput
    extends GUpdateEnterpriseMembersCanDeleteIssuesSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(enterpriseId,
        'GUpdateEnterpriseMembersCanDeleteIssuesSettingInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(settingValue,
        'GUpdateEnterpriseMembersCanDeleteIssuesSettingInput', 'settingValue');
  }

  @override
  GUpdateEnterpriseMembersCanDeleteIssuesSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder toBuilder() =>
      new GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder()
        ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseMembersCanDeleteIssuesSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanDeleteIssuesSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseMembersCanDeleteIssuesSettingInput,
            GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder();

  GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseMembersCanDeleteIssuesSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput;
  }

  @override
  void update(
      void Function(GUpdateEnterpriseMembersCanDeleteIssuesSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanDeleteIssuesSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanDeleteIssuesSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseMembersCanDeleteIssuesSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput
    extends GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput,
            GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder();

  GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput
    extends GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other
            is GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput,
            GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder();

  GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput
    extends GUpdateEnterpriseMembersCanMakePurchasesSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseMembersCanMakePurchasesSettingValue settingValue;

  factory _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(enterpriseId,
        'GUpdateEnterpriseMembersCanMakePurchasesSettingInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(settingValue,
        'GUpdateEnterpriseMembersCanMakePurchasesSettingInput', 'settingValue');
  }

  @override
  GUpdateEnterpriseMembersCanMakePurchasesSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder toBuilder() =>
      new GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder()
        ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseMembersCanMakePurchasesSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanMakePurchasesSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseMembersCanMakePurchasesSettingInput,
            GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseMembersCanMakePurchasesSettingValue? _settingValue;
  GEnterpriseMembersCanMakePurchasesSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(
          GEnterpriseMembersCanMakePurchasesSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder();

  GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseMembersCanMakePurchasesSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseMembersCanMakePurchasesSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanMakePurchasesSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanMakePurchasesSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseMembersCanMakePurchasesSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput
    extends GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other
            is GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput,
            GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder();

  GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder
      get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other
        as _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput
    extends GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput(
          [void Function(
                  GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other
            is GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput,
            GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder> {
  _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder();

  GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder
      get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other
        as _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseOrganizationProjectsSettingInput
    extends GUpdateEnterpriseOrganizationProjectsSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseOrganizationProjectsSettingInput(
          [void Function(
                  GUpdateEnterpriseOrganizationProjectsSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseOrganizationProjectsSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseOrganizationProjectsSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(enterpriseId,
        'GUpdateEnterpriseOrganizationProjectsSettingInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(settingValue,
        'GUpdateEnterpriseOrganizationProjectsSettingInput', 'settingValue');
  }

  @override
  GUpdateEnterpriseOrganizationProjectsSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseOrganizationProjectsSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseOrganizationProjectsSettingInputBuilder toBuilder() =>
      new GUpdateEnterpriseOrganizationProjectsSettingInputBuilder()
        ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseOrganizationProjectsSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseOrganizationProjectsSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseOrganizationProjectsSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseOrganizationProjectsSettingInput,
            GUpdateEnterpriseOrganizationProjectsSettingInputBuilder> {
  _$GUpdateEnterpriseOrganizationProjectsSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseOrganizationProjectsSettingInputBuilder();

  GUpdateEnterpriseOrganizationProjectsSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseOrganizationProjectsSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseOrganizationProjectsSettingInput;
  }

  @override
  void update(
      void Function(GUpdateEnterpriseOrganizationProjectsSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseOrganizationProjectsSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseOrganizationProjectsSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseOrganizationProjectsSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseOrganizationProjectsSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseProfileInput extends GUpdateEnterpriseProfileInput {
  @override
  final String? clientMutationId;
  @override
  final String? description;
  @override
  final String enterpriseId;
  @override
  final String? location;
  @override
  final String? name;
  @override
  final String? websiteUrl;

  factory _$GUpdateEnterpriseProfileInput(
          [void Function(GUpdateEnterpriseProfileInputBuilder)? updates]) =>
      (new GUpdateEnterpriseProfileInputBuilder()..update(updates)).build();

  _$GUpdateEnterpriseProfileInput._(
      {this.clientMutationId,
      this.description,
      required this.enterpriseId,
      this.location,
      this.name,
      this.websiteUrl})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId, 'GUpdateEnterpriseProfileInput', 'enterpriseId');
  }

  @override
  GUpdateEnterpriseProfileInput rebuild(
          void Function(GUpdateEnterpriseProfileInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseProfileInputBuilder toBuilder() =>
      new GUpdateEnterpriseProfileInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseProfileInput &&
        clientMutationId == other.clientMutationId &&
        description == other.description &&
        enterpriseId == other.enterpriseId &&
        location == other.location &&
        name == other.name &&
        websiteUrl == other.websiteUrl;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc($jc(0, clientMutationId.hashCode),
                        description.hashCode),
                    enterpriseId.hashCode),
                location.hashCode),
            name.hashCode),
        websiteUrl.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateEnterpriseProfileInput')
          ..add('clientMutationId', clientMutationId)
          ..add('description', description)
          ..add('enterpriseId', enterpriseId)
          ..add('location', location)
          ..add('name', name)
          ..add('websiteUrl', websiteUrl))
        .toString();
  }
}

class GUpdateEnterpriseProfileInputBuilder
    implements
        Builder<GUpdateEnterpriseProfileInput,
            GUpdateEnterpriseProfileInputBuilder> {
  _$GUpdateEnterpriseProfileInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _description;
  String? get description => _$this._description;
  set description(String? description) => _$this._description = description;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  String? _location;
  String? get location => _$this._location;
  set location(String? location) => _$this._location = location;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _websiteUrl;
  String? get websiteUrl => _$this._websiteUrl;
  set websiteUrl(String? websiteUrl) => _$this._websiteUrl = websiteUrl;

  GUpdateEnterpriseProfileInputBuilder();

  GUpdateEnterpriseProfileInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _description = $v.description;
      _enterpriseId = $v.enterpriseId;
      _location = $v.location;
      _name = $v.name;
      _websiteUrl = $v.websiteUrl;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseProfileInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseProfileInput;
  }

  @override
  void update(void Function(GUpdateEnterpriseProfileInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseProfileInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseProfileInput._(
            clientMutationId: clientMutationId,
            description: description,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId, 'GUpdateEnterpriseProfileInput', 'enterpriseId'),
            location: location,
            name: name,
            websiteUrl: websiteUrl);
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseRepositoryProjectsSettingInput
    extends GUpdateEnterpriseRepositoryProjectsSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseRepositoryProjectsSettingInput(
          [void Function(
                  GUpdateEnterpriseRepositoryProjectsSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseRepositoryProjectsSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseRepositoryProjectsSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(enterpriseId,
        'GUpdateEnterpriseRepositoryProjectsSettingInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(settingValue,
        'GUpdateEnterpriseRepositoryProjectsSettingInput', 'settingValue');
  }

  @override
  GUpdateEnterpriseRepositoryProjectsSettingInput rebuild(
          void Function(GUpdateEnterpriseRepositoryProjectsSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseRepositoryProjectsSettingInputBuilder toBuilder() =>
      new GUpdateEnterpriseRepositoryProjectsSettingInputBuilder()
        ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseRepositoryProjectsSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseRepositoryProjectsSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseRepositoryProjectsSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseRepositoryProjectsSettingInput,
            GUpdateEnterpriseRepositoryProjectsSettingInputBuilder> {
  _$GUpdateEnterpriseRepositoryProjectsSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseRepositoryProjectsSettingInputBuilder();

  GUpdateEnterpriseRepositoryProjectsSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseRepositoryProjectsSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseRepositoryProjectsSettingInput;
  }

  @override
  void update(
      void Function(GUpdateEnterpriseRepositoryProjectsSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseRepositoryProjectsSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseRepositoryProjectsSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseRepositoryProjectsSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseRepositoryProjectsSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseTeamDiscussionsSettingInput
    extends GUpdateEnterpriseTeamDiscussionsSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledDisabledSettingValue settingValue;

  factory _$GUpdateEnterpriseTeamDiscussionsSettingInput(
          [void Function(GUpdateEnterpriseTeamDiscussionsSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseTeamDiscussionsSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseTeamDiscussionsSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(enterpriseId,
        'GUpdateEnterpriseTeamDiscussionsSettingInput', 'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(settingValue,
        'GUpdateEnterpriseTeamDiscussionsSettingInput', 'settingValue');
  }

  @override
  GUpdateEnterpriseTeamDiscussionsSettingInput rebuild(
          void Function(GUpdateEnterpriseTeamDiscussionsSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseTeamDiscussionsSettingInputBuilder toBuilder() =>
      new GUpdateEnterpriseTeamDiscussionsSettingInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnterpriseTeamDiscussionsSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseTeamDiscussionsSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseTeamDiscussionsSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseTeamDiscussionsSettingInput,
            GUpdateEnterpriseTeamDiscussionsSettingInputBuilder> {
  _$GUpdateEnterpriseTeamDiscussionsSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledDisabledSettingValue? _settingValue;
  GEnterpriseEnabledDisabledSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GEnterpriseEnabledDisabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseTeamDiscussionsSettingInputBuilder();

  GUpdateEnterpriseTeamDiscussionsSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseTeamDiscussionsSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnterpriseTeamDiscussionsSettingInput;
  }

  @override
  void update(
      void Function(GUpdateEnterpriseTeamDiscussionsSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseTeamDiscussionsSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseTeamDiscussionsSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(enterpriseId,
                'GUpdateEnterpriseTeamDiscussionsSettingInput', 'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseTeamDiscussionsSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput
    extends GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String enterpriseId;
  @override
  final GEnterpriseEnabledSettingValue settingValue;

  factory _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput(
          [void Function(
                  GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder)?
              updates]) =>
      (new GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder()
            ..update(updates))
          .build();

  _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput._(
      {this.clientMutationId,
      required this.enterpriseId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        enterpriseId,
        'GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput',
        'enterpriseId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue,
        'GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput',
        'settingValue');
  }

  @override
  GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput rebuild(
          void Function(
                  GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder
      toBuilder() =>
          new GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder()
            ..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other
            is GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput &&
        clientMutationId == other.clientMutationId &&
        enterpriseId == other.enterpriseId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), enterpriseId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('enterpriseId', enterpriseId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder
    implements
        Builder<GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput,
            GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder> {
  _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _enterpriseId;
  String? get enterpriseId => _$this._enterpriseId;
  set enterpriseId(String? enterpriseId) => _$this._enterpriseId = enterpriseId;

  GEnterpriseEnabledSettingValue? _settingValue;
  GEnterpriseEnabledSettingValue? get settingValue => _$this._settingValue;
  set settingValue(GEnterpriseEnabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder();

  GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder
      get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _enterpriseId = $v.enterpriseId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v =
        other as _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput;
  }

  @override
  void update(
      void Function(
              GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput._(
            clientMutationId: clientMutationId,
            enterpriseId: BuiltValueNullFieldError.checkNotNull(
                enterpriseId,
                'GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput',
                'enterpriseId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(
                settingValue,
                'GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput',
                'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateEnvironmentInput extends GUpdateEnvironmentInput {
  @override
  final String? clientMutationId;
  @override
  final String environmentId;
  @override
  final BuiltList<String>? reviewers;
  @override
  final int? waitTimer;

  factory _$GUpdateEnvironmentInput(
          [void Function(GUpdateEnvironmentInputBuilder)? updates]) =>
      (new GUpdateEnvironmentInputBuilder()..update(updates)).build();

  _$GUpdateEnvironmentInput._(
      {this.clientMutationId,
      required this.environmentId,
      this.reviewers,
      this.waitTimer})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        environmentId, 'GUpdateEnvironmentInput', 'environmentId');
  }

  @override
  GUpdateEnvironmentInput rebuild(
          void Function(GUpdateEnvironmentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateEnvironmentInputBuilder toBuilder() =>
      new GUpdateEnvironmentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateEnvironmentInput &&
        clientMutationId == other.clientMutationId &&
        environmentId == other.environmentId &&
        reviewers == other.reviewers &&
        waitTimer == other.waitTimer;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), environmentId.hashCode),
            reviewers.hashCode),
        waitTimer.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateEnvironmentInput')
          ..add('clientMutationId', clientMutationId)
          ..add('environmentId', environmentId)
          ..add('reviewers', reviewers)
          ..add('waitTimer', waitTimer))
        .toString();
  }
}

class GUpdateEnvironmentInputBuilder
    implements
        Builder<GUpdateEnvironmentInput, GUpdateEnvironmentInputBuilder> {
  _$GUpdateEnvironmentInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _environmentId;
  String? get environmentId => _$this._environmentId;
  set environmentId(String? environmentId) =>
      _$this._environmentId = environmentId;

  ListBuilder<String>? _reviewers;
  ListBuilder<String> get reviewers =>
      _$this._reviewers ??= new ListBuilder<String>();
  set reviewers(ListBuilder<String>? reviewers) =>
      _$this._reviewers = reviewers;

  int? _waitTimer;
  int? get waitTimer => _$this._waitTimer;
  set waitTimer(int? waitTimer) => _$this._waitTimer = waitTimer;

  GUpdateEnvironmentInputBuilder();

  GUpdateEnvironmentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _environmentId = $v.environmentId;
      _reviewers = $v.reviewers?.toBuilder();
      _waitTimer = $v.waitTimer;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnvironmentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateEnvironmentInput;
  }

  @override
  void update(void Function(GUpdateEnvironmentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateEnvironmentInput build() {
    _$GUpdateEnvironmentInput _$result;
    try {
      _$result = _$v ??
          new _$GUpdateEnvironmentInput._(
              clientMutationId: clientMutationId,
              environmentId: BuiltValueNullFieldError.checkNotNull(
                  environmentId, 'GUpdateEnvironmentInput', 'environmentId'),
              reviewers: _reviewers?.build(),
              waitTimer: waitTimer);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'reviewers';
        _reviewers?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdateEnvironmentInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateIpAllowListEnabledSettingInput
    extends GUpdateIpAllowListEnabledSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String ownerId;
  @override
  final GIpAllowListEnabledSettingValue settingValue;

  factory _$GUpdateIpAllowListEnabledSettingInput(
          [void Function(GUpdateIpAllowListEnabledSettingInputBuilder)?
              updates]) =>
      (new GUpdateIpAllowListEnabledSettingInputBuilder()..update(updates))
          .build();

  _$GUpdateIpAllowListEnabledSettingInput._(
      {this.clientMutationId,
      required this.ownerId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        ownerId, 'GUpdateIpAllowListEnabledSettingInput', 'ownerId');
    BuiltValueNullFieldError.checkNotNull(
        settingValue, 'GUpdateIpAllowListEnabledSettingInput', 'settingValue');
  }

  @override
  GUpdateIpAllowListEnabledSettingInput rebuild(
          void Function(GUpdateIpAllowListEnabledSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateIpAllowListEnabledSettingInputBuilder toBuilder() =>
      new GUpdateIpAllowListEnabledSettingInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateIpAllowListEnabledSettingInput &&
        clientMutationId == other.clientMutationId &&
        ownerId == other.ownerId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), ownerId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateIpAllowListEnabledSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('ownerId', ownerId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateIpAllowListEnabledSettingInputBuilder
    implements
        Builder<GUpdateIpAllowListEnabledSettingInput,
            GUpdateIpAllowListEnabledSettingInputBuilder> {
  _$GUpdateIpAllowListEnabledSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _ownerId;
  String? get ownerId => _$this._ownerId;
  set ownerId(String? ownerId) => _$this._ownerId = ownerId;

  GIpAllowListEnabledSettingValue? _settingValue;
  GIpAllowListEnabledSettingValue? get settingValue => _$this._settingValue;
  set settingValue(GIpAllowListEnabledSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateIpAllowListEnabledSettingInputBuilder();

  GUpdateIpAllowListEnabledSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _ownerId = $v.ownerId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateIpAllowListEnabledSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateIpAllowListEnabledSettingInput;
  }

  @override
  void update(
      void Function(GUpdateIpAllowListEnabledSettingInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateIpAllowListEnabledSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateIpAllowListEnabledSettingInput._(
            clientMutationId: clientMutationId,
            ownerId: BuiltValueNullFieldError.checkNotNull(
                ownerId, 'GUpdateIpAllowListEnabledSettingInput', 'ownerId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(settingValue,
                'GUpdateIpAllowListEnabledSettingInput', 'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateIpAllowListEntryInput extends GUpdateIpAllowListEntryInput {
  @override
  final String allowListValue;
  @override
  final String? clientMutationId;
  @override
  final String ipAllowListEntryId;
  @override
  final bool isActive;
  @override
  final String? name;

  factory _$GUpdateIpAllowListEntryInput(
          [void Function(GUpdateIpAllowListEntryInputBuilder)? updates]) =>
      (new GUpdateIpAllowListEntryInputBuilder()..update(updates)).build();

  _$GUpdateIpAllowListEntryInput._(
      {required this.allowListValue,
      this.clientMutationId,
      required this.ipAllowListEntryId,
      required this.isActive,
      this.name})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        allowListValue, 'GUpdateIpAllowListEntryInput', 'allowListValue');
    BuiltValueNullFieldError.checkNotNull(ipAllowListEntryId,
        'GUpdateIpAllowListEntryInput', 'ipAllowListEntryId');
    BuiltValueNullFieldError.checkNotNull(
        isActive, 'GUpdateIpAllowListEntryInput', 'isActive');
  }

  @override
  GUpdateIpAllowListEntryInput rebuild(
          void Function(GUpdateIpAllowListEntryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateIpAllowListEntryInputBuilder toBuilder() =>
      new GUpdateIpAllowListEntryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateIpAllowListEntryInput &&
        allowListValue == other.allowListValue &&
        clientMutationId == other.clientMutationId &&
        ipAllowListEntryId == other.ipAllowListEntryId &&
        isActive == other.isActive &&
        name == other.name;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc($jc($jc(0, allowListValue.hashCode), clientMutationId.hashCode),
                ipAllowListEntryId.hashCode),
            isActive.hashCode),
        name.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateIpAllowListEntryInput')
          ..add('allowListValue', allowListValue)
          ..add('clientMutationId', clientMutationId)
          ..add('ipAllowListEntryId', ipAllowListEntryId)
          ..add('isActive', isActive)
          ..add('name', name))
        .toString();
  }
}

class GUpdateIpAllowListEntryInputBuilder
    implements
        Builder<GUpdateIpAllowListEntryInput,
            GUpdateIpAllowListEntryInputBuilder> {
  _$GUpdateIpAllowListEntryInput? _$v;

  String? _allowListValue;
  String? get allowListValue => _$this._allowListValue;
  set allowListValue(String? allowListValue) =>
      _$this._allowListValue = allowListValue;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _ipAllowListEntryId;
  String? get ipAllowListEntryId => _$this._ipAllowListEntryId;
  set ipAllowListEntryId(String? ipAllowListEntryId) =>
      _$this._ipAllowListEntryId = ipAllowListEntryId;

  bool? _isActive;
  bool? get isActive => _$this._isActive;
  set isActive(bool? isActive) => _$this._isActive = isActive;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  GUpdateIpAllowListEntryInputBuilder();

  GUpdateIpAllowListEntryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _allowListValue = $v.allowListValue;
      _clientMutationId = $v.clientMutationId;
      _ipAllowListEntryId = $v.ipAllowListEntryId;
      _isActive = $v.isActive;
      _name = $v.name;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateIpAllowListEntryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateIpAllowListEntryInput;
  }

  @override
  void update(void Function(GUpdateIpAllowListEntryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateIpAllowListEntryInput build() {
    final _$result = _$v ??
        new _$GUpdateIpAllowListEntryInput._(
            allowListValue: BuiltValueNullFieldError.checkNotNull(
                allowListValue,
                'GUpdateIpAllowListEntryInput',
                'allowListValue'),
            clientMutationId: clientMutationId,
            ipAllowListEntryId: BuiltValueNullFieldError.checkNotNull(
                ipAllowListEntryId,
                'GUpdateIpAllowListEntryInput',
                'ipAllowListEntryId'),
            isActive: BuiltValueNullFieldError.checkNotNull(
                isActive, 'GUpdateIpAllowListEntryInput', 'isActive'),
            name: name);
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateIssueCommentInput extends GUpdateIssueCommentInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GUpdateIssueCommentInput(
          [void Function(GUpdateIssueCommentInputBuilder)? updates]) =>
      (new GUpdateIssueCommentInputBuilder()..update(updates)).build();

  _$GUpdateIssueCommentInput._(
      {required this.body, this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GUpdateIssueCommentInput', 'body');
    BuiltValueNullFieldError.checkNotNull(id, 'GUpdateIssueCommentInput', 'id');
  }

  @override
  GUpdateIssueCommentInput rebuild(
          void Function(GUpdateIssueCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateIssueCommentInputBuilder toBuilder() =>
      new GUpdateIssueCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateIssueCommentInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, body.hashCode), clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateIssueCommentInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GUpdateIssueCommentInputBuilder
    implements
        Builder<GUpdateIssueCommentInput, GUpdateIssueCommentInputBuilder> {
  _$GUpdateIssueCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GUpdateIssueCommentInputBuilder();

  GUpdateIssueCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateIssueCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateIssueCommentInput;
  }

  @override
  void update(void Function(GUpdateIssueCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateIssueCommentInput build() {
    final _$result = _$v ??
        new _$GUpdateIssueCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GUpdateIssueCommentInput', 'body'),
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GUpdateIssueCommentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateIssueInput extends GUpdateIssueInput {
  @override
  final BuiltList<String>? assigneeIds;
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final String id;
  @override
  final BuiltList<String>? labelIds;
  @override
  final String? milestoneId;
  @override
  final BuiltList<String>? projectIds;
  @override
  final GIssueState? state;
  @override
  final String? title;

  factory _$GUpdateIssueInput(
          [void Function(GUpdateIssueInputBuilder)? updates]) =>
      (new GUpdateIssueInputBuilder()..update(updates)).build();

  _$GUpdateIssueInput._(
      {this.assigneeIds,
      this.body,
      this.clientMutationId,
      required this.id,
      this.labelIds,
      this.milestoneId,
      this.projectIds,
      this.state,
      this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(id, 'GUpdateIssueInput', 'id');
  }

  @override
  GUpdateIssueInput rebuild(void Function(GUpdateIssueInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateIssueInputBuilder toBuilder() =>
      new GUpdateIssueInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateIssueInput &&
        assigneeIds == other.assigneeIds &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        id == other.id &&
        labelIds == other.labelIds &&
        milestoneId == other.milestoneId &&
        projectIds == other.projectIds &&
        state == other.state &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc($jc(0, assigneeIds.hashCode),
                                    body.hashCode),
                                clientMutationId.hashCode),
                            id.hashCode),
                        labelIds.hashCode),
                    milestoneId.hashCode),
                projectIds.hashCode),
            state.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateIssueInput')
          ..add('assigneeIds', assigneeIds)
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('id', id)
          ..add('labelIds', labelIds)
          ..add('milestoneId', milestoneId)
          ..add('projectIds', projectIds)
          ..add('state', state)
          ..add('title', title))
        .toString();
  }
}

class GUpdateIssueInputBuilder
    implements Builder<GUpdateIssueInput, GUpdateIssueInputBuilder> {
  _$GUpdateIssueInput? _$v;

  ListBuilder<String>? _assigneeIds;
  ListBuilder<String> get assigneeIds =>
      _$this._assigneeIds ??= new ListBuilder<String>();
  set assigneeIds(ListBuilder<String>? assigneeIds) =>
      _$this._assigneeIds = assigneeIds;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  ListBuilder<String>? _labelIds;
  ListBuilder<String> get labelIds =>
      _$this._labelIds ??= new ListBuilder<String>();
  set labelIds(ListBuilder<String>? labelIds) => _$this._labelIds = labelIds;

  String? _milestoneId;
  String? get milestoneId => _$this._milestoneId;
  set milestoneId(String? milestoneId) => _$this._milestoneId = milestoneId;

  ListBuilder<String>? _projectIds;
  ListBuilder<String> get projectIds =>
      _$this._projectIds ??= new ListBuilder<String>();
  set projectIds(ListBuilder<String>? projectIds) =>
      _$this._projectIds = projectIds;

  GIssueState? _state;
  GIssueState? get state => _$this._state;
  set state(GIssueState? state) => _$this._state = state;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GUpdateIssueInputBuilder();

  GUpdateIssueInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _assigneeIds = $v.assigneeIds?.toBuilder();
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _labelIds = $v.labelIds?.toBuilder();
      _milestoneId = $v.milestoneId;
      _projectIds = $v.projectIds?.toBuilder();
      _state = $v.state;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateIssueInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateIssueInput;
  }

  @override
  void update(void Function(GUpdateIssueInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateIssueInput build() {
    _$GUpdateIssueInput _$result;
    try {
      _$result = _$v ??
          new _$GUpdateIssueInput._(
              assigneeIds: _assigneeIds?.build(),
              body: body,
              clientMutationId: clientMutationId,
              id: BuiltValueNullFieldError.checkNotNull(
                  id, 'GUpdateIssueInput', 'id'),
              labelIds: _labelIds?.build(),
              milestoneId: milestoneId,
              projectIds: _projectIds?.build(),
              state: state,
              title: title);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'assigneeIds';
        _assigneeIds?.build();

        _$failedField = 'labelIds';
        _labelIds?.build();

        _$failedField = 'projectIds';
        _projectIds?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdateIssueInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateNotificationRestrictionSettingInput
    extends GUpdateNotificationRestrictionSettingInput {
  @override
  final String? clientMutationId;
  @override
  final String ownerId;
  @override
  final GNotificationRestrictionSettingValue settingValue;

  factory _$GUpdateNotificationRestrictionSettingInput(
          [void Function(GUpdateNotificationRestrictionSettingInputBuilder)?
              updates]) =>
      (new GUpdateNotificationRestrictionSettingInputBuilder()..update(updates))
          .build();

  _$GUpdateNotificationRestrictionSettingInput._(
      {this.clientMutationId,
      required this.ownerId,
      required this.settingValue})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        ownerId, 'GUpdateNotificationRestrictionSettingInput', 'ownerId');
    BuiltValueNullFieldError.checkNotNull(settingValue,
        'GUpdateNotificationRestrictionSettingInput', 'settingValue');
  }

  @override
  GUpdateNotificationRestrictionSettingInput rebuild(
          void Function(GUpdateNotificationRestrictionSettingInputBuilder)
              updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateNotificationRestrictionSettingInputBuilder toBuilder() =>
      new GUpdateNotificationRestrictionSettingInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateNotificationRestrictionSettingInput &&
        clientMutationId == other.clientMutationId &&
        ownerId == other.ownerId &&
        settingValue == other.settingValue;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), ownerId.hashCode),
        settingValue.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper(
            'GUpdateNotificationRestrictionSettingInput')
          ..add('clientMutationId', clientMutationId)
          ..add('ownerId', ownerId)
          ..add('settingValue', settingValue))
        .toString();
  }
}

class GUpdateNotificationRestrictionSettingInputBuilder
    implements
        Builder<GUpdateNotificationRestrictionSettingInput,
            GUpdateNotificationRestrictionSettingInputBuilder> {
  _$GUpdateNotificationRestrictionSettingInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _ownerId;
  String? get ownerId => _$this._ownerId;
  set ownerId(String? ownerId) => _$this._ownerId = ownerId;

  GNotificationRestrictionSettingValue? _settingValue;
  GNotificationRestrictionSettingValue? get settingValue =>
      _$this._settingValue;
  set settingValue(GNotificationRestrictionSettingValue? settingValue) =>
      _$this._settingValue = settingValue;

  GUpdateNotificationRestrictionSettingInputBuilder();

  GUpdateNotificationRestrictionSettingInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _ownerId = $v.ownerId;
      _settingValue = $v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateNotificationRestrictionSettingInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateNotificationRestrictionSettingInput;
  }

  @override
  void update(
      void Function(GUpdateNotificationRestrictionSettingInputBuilder)?
          updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateNotificationRestrictionSettingInput build() {
    final _$result = _$v ??
        new _$GUpdateNotificationRestrictionSettingInput._(
            clientMutationId: clientMutationId,
            ownerId: BuiltValueNullFieldError.checkNotNull(ownerId,
                'GUpdateNotificationRestrictionSettingInput', 'ownerId'),
            settingValue: BuiltValueNullFieldError.checkNotNull(settingValue,
                'GUpdateNotificationRestrictionSettingInput', 'settingValue'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateProjectCardInput extends GUpdateProjectCardInput {
  @override
  final String? clientMutationId;
  @override
  final bool? isArchived;
  @override
  final String? note;
  @override
  final String projectCardId;

  factory _$GUpdateProjectCardInput(
          [void Function(GUpdateProjectCardInputBuilder)? updates]) =>
      (new GUpdateProjectCardInputBuilder()..update(updates)).build();

  _$GUpdateProjectCardInput._(
      {this.clientMutationId,
      this.isArchived,
      this.note,
      required this.projectCardId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        projectCardId, 'GUpdateProjectCardInput', 'projectCardId');
  }

  @override
  GUpdateProjectCardInput rebuild(
          void Function(GUpdateProjectCardInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateProjectCardInputBuilder toBuilder() =>
      new GUpdateProjectCardInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateProjectCardInput &&
        clientMutationId == other.clientMutationId &&
        isArchived == other.isArchived &&
        note == other.note &&
        projectCardId == other.projectCardId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), isArchived.hashCode),
            note.hashCode),
        projectCardId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateProjectCardInput')
          ..add('clientMutationId', clientMutationId)
          ..add('isArchived', isArchived)
          ..add('note', note)
          ..add('projectCardId', projectCardId))
        .toString();
  }
}

class GUpdateProjectCardInputBuilder
    implements
        Builder<GUpdateProjectCardInput, GUpdateProjectCardInputBuilder> {
  _$GUpdateProjectCardInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _isArchived;
  bool? get isArchived => _$this._isArchived;
  set isArchived(bool? isArchived) => _$this._isArchived = isArchived;

  String? _note;
  String? get note => _$this._note;
  set note(String? note) => _$this._note = note;

  String? _projectCardId;
  String? get projectCardId => _$this._projectCardId;
  set projectCardId(String? projectCardId) =>
      _$this._projectCardId = projectCardId;

  GUpdateProjectCardInputBuilder();

  GUpdateProjectCardInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _isArchived = $v.isArchived;
      _note = $v.note;
      _projectCardId = $v.projectCardId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateProjectCardInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateProjectCardInput;
  }

  @override
  void update(void Function(GUpdateProjectCardInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateProjectCardInput build() {
    final _$result = _$v ??
        new _$GUpdateProjectCardInput._(
            clientMutationId: clientMutationId,
            isArchived: isArchived,
            note: note,
            projectCardId: BuiltValueNullFieldError.checkNotNull(
                projectCardId, 'GUpdateProjectCardInput', 'projectCardId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateProjectColumnInput extends GUpdateProjectColumnInput {
  @override
  final String? clientMutationId;
  @override
  final String name;
  @override
  final String projectColumnId;

  factory _$GUpdateProjectColumnInput(
          [void Function(GUpdateProjectColumnInputBuilder)? updates]) =>
      (new GUpdateProjectColumnInputBuilder()..update(updates)).build();

  _$GUpdateProjectColumnInput._(
      {this.clientMutationId,
      required this.name,
      required this.projectColumnId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        name, 'GUpdateProjectColumnInput', 'name');
    BuiltValueNullFieldError.checkNotNull(
        projectColumnId, 'GUpdateProjectColumnInput', 'projectColumnId');
  }

  @override
  GUpdateProjectColumnInput rebuild(
          void Function(GUpdateProjectColumnInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateProjectColumnInputBuilder toBuilder() =>
      new GUpdateProjectColumnInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateProjectColumnInput &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        projectColumnId == other.projectColumnId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), name.hashCode),
        projectColumnId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateProjectColumnInput')
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('projectColumnId', projectColumnId))
        .toString();
  }
}

class GUpdateProjectColumnInputBuilder
    implements
        Builder<GUpdateProjectColumnInput, GUpdateProjectColumnInputBuilder> {
  _$GUpdateProjectColumnInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _projectColumnId;
  String? get projectColumnId => _$this._projectColumnId;
  set projectColumnId(String? projectColumnId) =>
      _$this._projectColumnId = projectColumnId;

  GUpdateProjectColumnInputBuilder();

  GUpdateProjectColumnInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _projectColumnId = $v.projectColumnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateProjectColumnInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateProjectColumnInput;
  }

  @override
  void update(void Function(GUpdateProjectColumnInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateProjectColumnInput build() {
    final _$result = _$v ??
        new _$GUpdateProjectColumnInput._(
            clientMutationId: clientMutationId,
            name: BuiltValueNullFieldError.checkNotNull(
                name, 'GUpdateProjectColumnInput', 'name'),
            projectColumnId: BuiltValueNullFieldError.checkNotNull(
                projectColumnId,
                'GUpdateProjectColumnInput',
                'projectColumnId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateProjectInput extends GUpdateProjectInput {
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final String? name;
  @override
  final String projectId;
  @override
  final bool? public;
  @override
  final GProjectState? state;

  factory _$GUpdateProjectInput(
          [void Function(GUpdateProjectInputBuilder)? updates]) =>
      (new GUpdateProjectInputBuilder()..update(updates)).build();

  _$GUpdateProjectInput._(
      {this.body,
      this.clientMutationId,
      this.name,
      required this.projectId,
      this.public,
      this.state})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        projectId, 'GUpdateProjectInput', 'projectId');
  }

  @override
  GUpdateProjectInput rebuild(
          void Function(GUpdateProjectInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateProjectInputBuilder toBuilder() =>
      new GUpdateProjectInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateProjectInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        name == other.name &&
        projectId == other.projectId &&
        public == other.public &&
        state == other.state;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
                    name.hashCode),
                projectId.hashCode),
            public.hashCode),
        state.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateProjectInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('name', name)
          ..add('projectId', projectId)
          ..add('public', public)
          ..add('state', state))
        .toString();
  }
}

class GUpdateProjectInputBuilder
    implements Builder<GUpdateProjectInput, GUpdateProjectInputBuilder> {
  _$GUpdateProjectInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _projectId;
  String? get projectId => _$this._projectId;
  set projectId(String? projectId) => _$this._projectId = projectId;

  bool? _public;
  bool? get public => _$this._public;
  set public(bool? public) => _$this._public = public;

  GProjectState? _state;
  GProjectState? get state => _$this._state;
  set state(GProjectState? state) => _$this._state = state;

  GUpdateProjectInputBuilder();

  GUpdateProjectInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _name = $v.name;
      _projectId = $v.projectId;
      _public = $v.public;
      _state = $v.state;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateProjectInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateProjectInput;
  }

  @override
  void update(void Function(GUpdateProjectInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateProjectInput build() {
    final _$result = _$v ??
        new _$GUpdateProjectInput._(
            body: body,
            clientMutationId: clientMutationId,
            name: name,
            projectId: BuiltValueNullFieldError.checkNotNull(
                projectId, 'GUpdateProjectInput', 'projectId'),
            public: public,
            state: state);
    replace(_$result);
    return _$result;
  }
}

class _$GUpdatePullRequestInput extends GUpdatePullRequestInput {
  @override
  final BuiltList<String>? assigneeIds;
  @override
  final String? baseRefName;
  @override
  final String? body;
  @override
  final String? clientMutationId;
  @override
  final BuiltList<String>? labelIds;
  @override
  final bool? maintainerCanModify;
  @override
  final String? milestoneId;
  @override
  final BuiltList<String>? projectIds;
  @override
  final String pullRequestId;
  @override
  final GPullRequestUpdateState? state;
  @override
  final String? title;

  factory _$GUpdatePullRequestInput(
          [void Function(GUpdatePullRequestInputBuilder)? updates]) =>
      (new GUpdatePullRequestInputBuilder()..update(updates)).build();

  _$GUpdatePullRequestInput._(
      {this.assigneeIds,
      this.baseRefName,
      this.body,
      this.clientMutationId,
      this.labelIds,
      this.maintainerCanModify,
      this.milestoneId,
      this.projectIds,
      required this.pullRequestId,
      this.state,
      this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        pullRequestId, 'GUpdatePullRequestInput', 'pullRequestId');
  }

  @override
  GUpdatePullRequestInput rebuild(
          void Function(GUpdatePullRequestInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdatePullRequestInputBuilder toBuilder() =>
      new GUpdatePullRequestInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdatePullRequestInput &&
        assigneeIds == other.assigneeIds &&
        baseRefName == other.baseRefName &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        labelIds == other.labelIds &&
        maintainerCanModify == other.maintainerCanModify &&
        milestoneId == other.milestoneId &&
        projectIds == other.projectIds &&
        pullRequestId == other.pullRequestId &&
        state == other.state &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc(
                                    $jc(
                                        $jc($jc(0, assigneeIds.hashCode),
                                            baseRefName.hashCode),
                                        body.hashCode),
                                    clientMutationId.hashCode),
                                labelIds.hashCode),
                            maintainerCanModify.hashCode),
                        milestoneId.hashCode),
                    projectIds.hashCode),
                pullRequestId.hashCode),
            state.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdatePullRequestInput')
          ..add('assigneeIds', assigneeIds)
          ..add('baseRefName', baseRefName)
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('labelIds', labelIds)
          ..add('maintainerCanModify', maintainerCanModify)
          ..add('milestoneId', milestoneId)
          ..add('projectIds', projectIds)
          ..add('pullRequestId', pullRequestId)
          ..add('state', state)
          ..add('title', title))
        .toString();
  }
}

class GUpdatePullRequestInputBuilder
    implements
        Builder<GUpdatePullRequestInput, GUpdatePullRequestInputBuilder> {
  _$GUpdatePullRequestInput? _$v;

  ListBuilder<String>? _assigneeIds;
  ListBuilder<String> get assigneeIds =>
      _$this._assigneeIds ??= new ListBuilder<String>();
  set assigneeIds(ListBuilder<String>? assigneeIds) =>
      _$this._assigneeIds = assigneeIds;

  String? _baseRefName;
  String? get baseRefName => _$this._baseRefName;
  set baseRefName(String? baseRefName) => _$this._baseRefName = baseRefName;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  ListBuilder<String>? _labelIds;
  ListBuilder<String> get labelIds =>
      _$this._labelIds ??= new ListBuilder<String>();
  set labelIds(ListBuilder<String>? labelIds) => _$this._labelIds = labelIds;

  bool? _maintainerCanModify;
  bool? get maintainerCanModify => _$this._maintainerCanModify;
  set maintainerCanModify(bool? maintainerCanModify) =>
      _$this._maintainerCanModify = maintainerCanModify;

  String? _milestoneId;
  String? get milestoneId => _$this._milestoneId;
  set milestoneId(String? milestoneId) => _$this._milestoneId = milestoneId;

  ListBuilder<String>? _projectIds;
  ListBuilder<String> get projectIds =>
      _$this._projectIds ??= new ListBuilder<String>();
  set projectIds(ListBuilder<String>? projectIds) =>
      _$this._projectIds = projectIds;

  String? _pullRequestId;
  String? get pullRequestId => _$this._pullRequestId;
  set pullRequestId(String? pullRequestId) =>
      _$this._pullRequestId = pullRequestId;

  GPullRequestUpdateState? _state;
  GPullRequestUpdateState? get state => _$this._state;
  set state(GPullRequestUpdateState? state) => _$this._state = state;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GUpdatePullRequestInputBuilder();

  GUpdatePullRequestInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _assigneeIds = $v.assigneeIds?.toBuilder();
      _baseRefName = $v.baseRefName;
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _labelIds = $v.labelIds?.toBuilder();
      _maintainerCanModify = $v.maintainerCanModify;
      _milestoneId = $v.milestoneId;
      _projectIds = $v.projectIds?.toBuilder();
      _pullRequestId = $v.pullRequestId;
      _state = $v.state;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdatePullRequestInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdatePullRequestInput;
  }

  @override
  void update(void Function(GUpdatePullRequestInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdatePullRequestInput build() {
    _$GUpdatePullRequestInput _$result;
    try {
      _$result = _$v ??
          new _$GUpdatePullRequestInput._(
              assigneeIds: _assigneeIds?.build(),
              baseRefName: baseRefName,
              body: body,
              clientMutationId: clientMutationId,
              labelIds: _labelIds?.build(),
              maintainerCanModify: maintainerCanModify,
              milestoneId: milestoneId,
              projectIds: _projectIds?.build(),
              pullRequestId: BuiltValueNullFieldError.checkNotNull(
                  pullRequestId, 'GUpdatePullRequestInput', 'pullRequestId'),
              state: state,
              title: title);
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'assigneeIds';
        _assigneeIds?.build();

        _$failedField = 'labelIds';
        _labelIds?.build();

        _$failedField = 'projectIds';
        _projectIds?.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdatePullRequestInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GUpdatePullRequestReviewCommentInput
    extends GUpdatePullRequestReviewCommentInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String pullRequestReviewCommentId;

  factory _$GUpdatePullRequestReviewCommentInput(
          [void Function(GUpdatePullRequestReviewCommentInputBuilder)?
              updates]) =>
      (new GUpdatePullRequestReviewCommentInputBuilder()..update(updates))
          .build();

  _$GUpdatePullRequestReviewCommentInput._(
      {required this.body,
      this.clientMutationId,
      required this.pullRequestReviewCommentId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GUpdatePullRequestReviewCommentInput', 'body');
    BuiltValueNullFieldError.checkNotNull(pullRequestReviewCommentId,
        'GUpdatePullRequestReviewCommentInput', 'pullRequestReviewCommentId');
  }

  @override
  GUpdatePullRequestReviewCommentInput rebuild(
          void Function(GUpdatePullRequestReviewCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdatePullRequestReviewCommentInputBuilder toBuilder() =>
      new GUpdatePullRequestReviewCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdatePullRequestReviewCommentInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        pullRequestReviewCommentId == other.pullRequestReviewCommentId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
        pullRequestReviewCommentId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdatePullRequestReviewCommentInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestReviewCommentId', pullRequestReviewCommentId))
        .toString();
  }
}

class GUpdatePullRequestReviewCommentInputBuilder
    implements
        Builder<GUpdatePullRequestReviewCommentInput,
            GUpdatePullRequestReviewCommentInputBuilder> {
  _$GUpdatePullRequestReviewCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestReviewCommentId;
  String? get pullRequestReviewCommentId => _$this._pullRequestReviewCommentId;
  set pullRequestReviewCommentId(String? pullRequestReviewCommentId) =>
      _$this._pullRequestReviewCommentId = pullRequestReviewCommentId;

  GUpdatePullRequestReviewCommentInputBuilder();

  GUpdatePullRequestReviewCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _pullRequestReviewCommentId = $v.pullRequestReviewCommentId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdatePullRequestReviewCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdatePullRequestReviewCommentInput;
  }

  @override
  void update(
      void Function(GUpdatePullRequestReviewCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdatePullRequestReviewCommentInput build() {
    final _$result = _$v ??
        new _$GUpdatePullRequestReviewCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GUpdatePullRequestReviewCommentInput', 'body'),
            clientMutationId: clientMutationId,
            pullRequestReviewCommentId: BuiltValueNullFieldError.checkNotNull(
                pullRequestReviewCommentId,
                'GUpdatePullRequestReviewCommentInput',
                'pullRequestReviewCommentId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdatePullRequestReviewInput extends GUpdatePullRequestReviewInput {
  @override
  final String body;
  @override
  final String? clientMutationId;
  @override
  final String pullRequestReviewId;

  factory _$GUpdatePullRequestReviewInput(
          [void Function(GUpdatePullRequestReviewInputBuilder)? updates]) =>
      (new GUpdatePullRequestReviewInputBuilder()..update(updates)).build();

  _$GUpdatePullRequestReviewInput._(
      {required this.body,
      this.clientMutationId,
      required this.pullRequestReviewId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GUpdatePullRequestReviewInput', 'body');
    BuiltValueNullFieldError.checkNotNull(pullRequestReviewId,
        'GUpdatePullRequestReviewInput', 'pullRequestReviewId');
  }

  @override
  GUpdatePullRequestReviewInput rebuild(
          void Function(GUpdatePullRequestReviewInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdatePullRequestReviewInputBuilder toBuilder() =>
      new GUpdatePullRequestReviewInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdatePullRequestReviewInput &&
        body == other.body &&
        clientMutationId == other.clientMutationId &&
        pullRequestReviewId == other.pullRequestReviewId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, body.hashCode), clientMutationId.hashCode),
        pullRequestReviewId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdatePullRequestReviewInput')
          ..add('body', body)
          ..add('clientMutationId', clientMutationId)
          ..add('pullRequestReviewId', pullRequestReviewId))
        .toString();
  }
}

class GUpdatePullRequestReviewInputBuilder
    implements
        Builder<GUpdatePullRequestReviewInput,
            GUpdatePullRequestReviewInputBuilder> {
  _$GUpdatePullRequestReviewInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _pullRequestReviewId;
  String? get pullRequestReviewId => _$this._pullRequestReviewId;
  set pullRequestReviewId(String? pullRequestReviewId) =>
      _$this._pullRequestReviewId = pullRequestReviewId;

  GUpdatePullRequestReviewInputBuilder();

  GUpdatePullRequestReviewInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _clientMutationId = $v.clientMutationId;
      _pullRequestReviewId = $v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdatePullRequestReviewInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdatePullRequestReviewInput;
  }

  @override
  void update(void Function(GUpdatePullRequestReviewInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdatePullRequestReviewInput build() {
    final _$result = _$v ??
        new _$GUpdatePullRequestReviewInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GUpdatePullRequestReviewInput', 'body'),
            clientMutationId: clientMutationId,
            pullRequestReviewId: BuiltValueNullFieldError.checkNotNull(
                pullRequestReviewId,
                'GUpdatePullRequestReviewInput',
                'pullRequestReviewId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateRefInput extends GUpdateRefInput {
  @override
  final String? clientMutationId;
  @override
  final bool? force;
  @override
  final String oid;
  @override
  final String refId;

  factory _$GUpdateRefInput([void Function(GUpdateRefInputBuilder)? updates]) =>
      (new GUpdateRefInputBuilder()..update(updates)).build();

  _$GUpdateRefInput._(
      {this.clientMutationId,
      this.force,
      required this.oid,
      required this.refId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(oid, 'GUpdateRefInput', 'oid');
    BuiltValueNullFieldError.checkNotNull(refId, 'GUpdateRefInput', 'refId');
  }

  @override
  GUpdateRefInput rebuild(void Function(GUpdateRefInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateRefInputBuilder toBuilder() =>
      new GUpdateRefInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateRefInput &&
        clientMutationId == other.clientMutationId &&
        force == other.force &&
        oid == other.oid &&
        refId == other.refId;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, clientMutationId.hashCode), force.hashCode),
            oid.hashCode),
        refId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateRefInput')
          ..add('clientMutationId', clientMutationId)
          ..add('force', force)
          ..add('oid', oid)
          ..add('refId', refId))
        .toString();
  }
}

class GUpdateRefInputBuilder
    implements Builder<GUpdateRefInput, GUpdateRefInputBuilder> {
  _$GUpdateRefInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  bool? _force;
  bool? get force => _$this._force;
  set force(bool? force) => _$this._force = force;

  String? _oid;
  String? get oid => _$this._oid;
  set oid(String? oid) => _$this._oid = oid;

  String? _refId;
  String? get refId => _$this._refId;
  set refId(String? refId) => _$this._refId = refId;

  GUpdateRefInputBuilder();

  GUpdateRefInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _force = $v.force;
      _oid = $v.oid;
      _refId = $v.refId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateRefInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateRefInput;
  }

  @override
  void update(void Function(GUpdateRefInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateRefInput build() {
    final _$result = _$v ??
        new _$GUpdateRefInput._(
            clientMutationId: clientMutationId,
            force: force,
            oid: BuiltValueNullFieldError.checkNotNull(
                oid, 'GUpdateRefInput', 'oid'),
            refId: BuiltValueNullFieldError.checkNotNull(
                refId, 'GUpdateRefInput', 'refId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateRepositoryInput extends GUpdateRepositoryInput {
  @override
  final String? clientMutationId;
  @override
  final String? description;
  @override
  final bool? hasIssuesEnabled;
  @override
  final bool? hasProjectsEnabled;
  @override
  final bool? hasWikiEnabled;
  @override
  final String? homepageUrl;
  @override
  final String? name;
  @override
  final String repositoryId;
  @override
  final bool? template;

  factory _$GUpdateRepositoryInput(
          [void Function(GUpdateRepositoryInputBuilder)? updates]) =>
      (new GUpdateRepositoryInputBuilder()..update(updates)).build();

  _$GUpdateRepositoryInput._(
      {this.clientMutationId,
      this.description,
      this.hasIssuesEnabled,
      this.hasProjectsEnabled,
      this.hasWikiEnabled,
      this.homepageUrl,
      this.name,
      required this.repositoryId,
      this.template})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GUpdateRepositoryInput', 'repositoryId');
  }

  @override
  GUpdateRepositoryInput rebuild(
          void Function(GUpdateRepositoryInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateRepositoryInputBuilder toBuilder() =>
      new GUpdateRepositoryInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateRepositoryInput &&
        clientMutationId == other.clientMutationId &&
        description == other.description &&
        hasIssuesEnabled == other.hasIssuesEnabled &&
        hasProjectsEnabled == other.hasProjectsEnabled &&
        hasWikiEnabled == other.hasWikiEnabled &&
        homepageUrl == other.homepageUrl &&
        name == other.name &&
        repositoryId == other.repositoryId &&
        template == other.template;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc(
                    $jc(
                        $jc(
                            $jc(
                                $jc($jc(0, clientMutationId.hashCode),
                                    description.hashCode),
                                hasIssuesEnabled.hashCode),
                            hasProjectsEnabled.hashCode),
                        hasWikiEnabled.hashCode),
                    homepageUrl.hashCode),
                name.hashCode),
            repositoryId.hashCode),
        template.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateRepositoryInput')
          ..add('clientMutationId', clientMutationId)
          ..add('description', description)
          ..add('hasIssuesEnabled', hasIssuesEnabled)
          ..add('hasProjectsEnabled', hasProjectsEnabled)
          ..add('hasWikiEnabled', hasWikiEnabled)
          ..add('homepageUrl', homepageUrl)
          ..add('name', name)
          ..add('repositoryId', repositoryId)
          ..add('template', template))
        .toString();
  }
}

class GUpdateRepositoryInputBuilder
    implements Builder<GUpdateRepositoryInput, GUpdateRepositoryInputBuilder> {
  _$GUpdateRepositoryInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _description;
  String? get description => _$this._description;
  set description(String? description) => _$this._description = description;

  bool? _hasIssuesEnabled;
  bool? get hasIssuesEnabled => _$this._hasIssuesEnabled;
  set hasIssuesEnabled(bool? hasIssuesEnabled) =>
      _$this._hasIssuesEnabled = hasIssuesEnabled;

  bool? _hasProjectsEnabled;
  bool? get hasProjectsEnabled => _$this._hasProjectsEnabled;
  set hasProjectsEnabled(bool? hasProjectsEnabled) =>
      _$this._hasProjectsEnabled = hasProjectsEnabled;

  bool? _hasWikiEnabled;
  bool? get hasWikiEnabled => _$this._hasWikiEnabled;
  set hasWikiEnabled(bool? hasWikiEnabled) =>
      _$this._hasWikiEnabled = hasWikiEnabled;

  String? _homepageUrl;
  String? get homepageUrl => _$this._homepageUrl;
  set homepageUrl(String? homepageUrl) => _$this._homepageUrl = homepageUrl;

  String? _name;
  String? get name => _$this._name;
  set name(String? name) => _$this._name = name;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  bool? _template;
  bool? get template => _$this._template;
  set template(bool? template) => _$this._template = template;

  GUpdateRepositoryInputBuilder();

  GUpdateRepositoryInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _description = $v.description;
      _hasIssuesEnabled = $v.hasIssuesEnabled;
      _hasProjectsEnabled = $v.hasProjectsEnabled;
      _hasWikiEnabled = $v.hasWikiEnabled;
      _homepageUrl = $v.homepageUrl;
      _name = $v.name;
      _repositoryId = $v.repositoryId;
      _template = $v.template;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateRepositoryInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateRepositoryInput;
  }

  @override
  void update(void Function(GUpdateRepositoryInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateRepositoryInput build() {
    final _$result = _$v ??
        new _$GUpdateRepositoryInput._(
            clientMutationId: clientMutationId,
            description: description,
            hasIssuesEnabled: hasIssuesEnabled,
            hasProjectsEnabled: hasProjectsEnabled,
            hasWikiEnabled: hasWikiEnabled,
            homepageUrl: homepageUrl,
            name: name,
            repositoryId: BuiltValueNullFieldError.checkNotNull(
                repositoryId, 'GUpdateRepositoryInput', 'repositoryId'),
            template: template);
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateSubscriptionInput extends GUpdateSubscriptionInput {
  @override
  final String? clientMutationId;
  @override
  final GSubscriptionState state;
  @override
  final String subscribableId;

  factory _$GUpdateSubscriptionInput(
          [void Function(GUpdateSubscriptionInputBuilder)? updates]) =>
      (new GUpdateSubscriptionInputBuilder()..update(updates)).build();

  _$GUpdateSubscriptionInput._(
      {this.clientMutationId,
      required this.state,
      required this.subscribableId})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        state, 'GUpdateSubscriptionInput', 'state');
    BuiltValueNullFieldError.checkNotNull(
        subscribableId, 'GUpdateSubscriptionInput', 'subscribableId');
  }

  @override
  GUpdateSubscriptionInput rebuild(
          void Function(GUpdateSubscriptionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateSubscriptionInputBuilder toBuilder() =>
      new GUpdateSubscriptionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateSubscriptionInput &&
        clientMutationId == other.clientMutationId &&
        state == other.state &&
        subscribableId == other.subscribableId;
  }

  @override
  int get hashCode {
    return $jf($jc($jc($jc(0, clientMutationId.hashCode), state.hashCode),
        subscribableId.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateSubscriptionInput')
          ..add('clientMutationId', clientMutationId)
          ..add('state', state)
          ..add('subscribableId', subscribableId))
        .toString();
  }
}

class GUpdateSubscriptionInputBuilder
    implements
        Builder<GUpdateSubscriptionInput, GUpdateSubscriptionInputBuilder> {
  _$GUpdateSubscriptionInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  GSubscriptionState? _state;
  GSubscriptionState? get state => _$this._state;
  set state(GSubscriptionState? state) => _$this._state = state;

  String? _subscribableId;
  String? get subscribableId => _$this._subscribableId;
  set subscribableId(String? subscribableId) =>
      _$this._subscribableId = subscribableId;

  GUpdateSubscriptionInputBuilder();

  GUpdateSubscriptionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _state = $v.state;
      _subscribableId = $v.subscribableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateSubscriptionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateSubscriptionInput;
  }

  @override
  void update(void Function(GUpdateSubscriptionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateSubscriptionInput build() {
    final _$result = _$v ??
        new _$GUpdateSubscriptionInput._(
            clientMutationId: clientMutationId,
            state: BuiltValueNullFieldError.checkNotNull(
                state, 'GUpdateSubscriptionInput', 'state'),
            subscribableId: BuiltValueNullFieldError.checkNotNull(
                subscribableId, 'GUpdateSubscriptionInput', 'subscribableId'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateTeamDiscussionCommentInput
    extends GUpdateTeamDiscussionCommentInput {
  @override
  final String body;
  @override
  final String? bodyVersion;
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GUpdateTeamDiscussionCommentInput(
          [void Function(GUpdateTeamDiscussionCommentInputBuilder)? updates]) =>
      (new GUpdateTeamDiscussionCommentInputBuilder()..update(updates)).build();

  _$GUpdateTeamDiscussionCommentInput._(
      {required this.body,
      this.bodyVersion,
      this.clientMutationId,
      required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        body, 'GUpdateTeamDiscussionCommentInput', 'body');
    BuiltValueNullFieldError.checkNotNull(
        id, 'GUpdateTeamDiscussionCommentInput', 'id');
  }

  @override
  GUpdateTeamDiscussionCommentInput rebuild(
          void Function(GUpdateTeamDiscussionCommentInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateTeamDiscussionCommentInputBuilder toBuilder() =>
      new GUpdateTeamDiscussionCommentInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateTeamDiscussionCommentInput &&
        body == other.body &&
        bodyVersion == other.bodyVersion &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc($jc(0, body.hashCode), bodyVersion.hashCode),
            clientMutationId.hashCode),
        id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateTeamDiscussionCommentInput')
          ..add('body', body)
          ..add('bodyVersion', bodyVersion)
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GUpdateTeamDiscussionCommentInputBuilder
    implements
        Builder<GUpdateTeamDiscussionCommentInput,
            GUpdateTeamDiscussionCommentInputBuilder> {
  _$GUpdateTeamDiscussionCommentInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _bodyVersion;
  String? get bodyVersion => _$this._bodyVersion;
  set bodyVersion(String? bodyVersion) => _$this._bodyVersion = bodyVersion;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GUpdateTeamDiscussionCommentInputBuilder();

  GUpdateTeamDiscussionCommentInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _bodyVersion = $v.bodyVersion;
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateTeamDiscussionCommentInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateTeamDiscussionCommentInput;
  }

  @override
  void update(
      void Function(GUpdateTeamDiscussionCommentInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateTeamDiscussionCommentInput build() {
    final _$result = _$v ??
        new _$GUpdateTeamDiscussionCommentInput._(
            body: BuiltValueNullFieldError.checkNotNull(
                body, 'GUpdateTeamDiscussionCommentInput', 'body'),
            bodyVersion: bodyVersion,
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GUpdateTeamDiscussionCommentInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateTeamDiscussionInput extends GUpdateTeamDiscussionInput {
  @override
  final String? body;
  @override
  final String? bodyVersion;
  @override
  final String? clientMutationId;
  @override
  final String id;
  @override
  final bool? pinned;
  @override
  final String? title;

  factory _$GUpdateTeamDiscussionInput(
          [void Function(GUpdateTeamDiscussionInputBuilder)? updates]) =>
      (new GUpdateTeamDiscussionInputBuilder()..update(updates)).build();

  _$GUpdateTeamDiscussionInput._(
      {this.body,
      this.bodyVersion,
      this.clientMutationId,
      required this.id,
      this.pinned,
      this.title})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GUpdateTeamDiscussionInput', 'id');
  }

  @override
  GUpdateTeamDiscussionInput rebuild(
          void Function(GUpdateTeamDiscussionInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateTeamDiscussionInputBuilder toBuilder() =>
      new GUpdateTeamDiscussionInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateTeamDiscussionInput &&
        body == other.body &&
        bodyVersion == other.bodyVersion &&
        clientMutationId == other.clientMutationId &&
        id == other.id &&
        pinned == other.pinned &&
        title == other.title;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc(
            $jc(
                $jc($jc($jc(0, body.hashCode), bodyVersion.hashCode),
                    clientMutationId.hashCode),
                id.hashCode),
            pinned.hashCode),
        title.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateTeamDiscussionInput')
          ..add('body', body)
          ..add('bodyVersion', bodyVersion)
          ..add('clientMutationId', clientMutationId)
          ..add('id', id)
          ..add('pinned', pinned)
          ..add('title', title))
        .toString();
  }
}

class GUpdateTeamDiscussionInputBuilder
    implements
        Builder<GUpdateTeamDiscussionInput, GUpdateTeamDiscussionInputBuilder> {
  _$GUpdateTeamDiscussionInput? _$v;

  String? _body;
  String? get body => _$this._body;
  set body(String? body) => _$this._body = body;

  String? _bodyVersion;
  String? get bodyVersion => _$this._bodyVersion;
  set bodyVersion(String? bodyVersion) => _$this._bodyVersion = bodyVersion;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  bool? _pinned;
  bool? get pinned => _$this._pinned;
  set pinned(bool? pinned) => _$this._pinned = pinned;

  String? _title;
  String? get title => _$this._title;
  set title(String? title) => _$this._title = title;

  GUpdateTeamDiscussionInputBuilder();

  GUpdateTeamDiscussionInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _body = $v.body;
      _bodyVersion = $v.bodyVersion;
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _pinned = $v.pinned;
      _title = $v.title;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateTeamDiscussionInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateTeamDiscussionInput;
  }

  @override
  void update(void Function(GUpdateTeamDiscussionInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateTeamDiscussionInput build() {
    final _$result = _$v ??
        new _$GUpdateTeamDiscussionInput._(
            body: body,
            bodyVersion: bodyVersion,
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GUpdateTeamDiscussionInput', 'id'),
            pinned: pinned,
            title: title);
    replace(_$result);
    return _$result;
  }
}

class _$GUpdateTopicsInput extends GUpdateTopicsInput {
  @override
  final String? clientMutationId;
  @override
  final String repositoryId;
  @override
  final BuiltList<String> topicNames;

  factory _$GUpdateTopicsInput(
          [void Function(GUpdateTopicsInputBuilder)? updates]) =>
      (new GUpdateTopicsInputBuilder()..update(updates)).build();

  _$GUpdateTopicsInput._(
      {this.clientMutationId,
      required this.repositoryId,
      required this.topicNames})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        repositoryId, 'GUpdateTopicsInput', 'repositoryId');
    BuiltValueNullFieldError.checkNotNull(
        topicNames, 'GUpdateTopicsInput', 'topicNames');
  }

  @override
  GUpdateTopicsInput rebuild(
          void Function(GUpdateTopicsInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUpdateTopicsInputBuilder toBuilder() =>
      new GUpdateTopicsInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUpdateTopicsInput &&
        clientMutationId == other.clientMutationId &&
        repositoryId == other.repositoryId &&
        topicNames == other.topicNames;
  }

  @override
  int get hashCode {
    return $jf($jc(
        $jc($jc(0, clientMutationId.hashCode), repositoryId.hashCode),
        topicNames.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUpdateTopicsInput')
          ..add('clientMutationId', clientMutationId)
          ..add('repositoryId', repositoryId)
          ..add('topicNames', topicNames))
        .toString();
  }
}

class GUpdateTopicsInputBuilder
    implements Builder<GUpdateTopicsInput, GUpdateTopicsInputBuilder> {
  _$GUpdateTopicsInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _repositoryId;
  String? get repositoryId => _$this._repositoryId;
  set repositoryId(String? repositoryId) => _$this._repositoryId = repositoryId;

  ListBuilder<String>? _topicNames;
  ListBuilder<String> get topicNames =>
      _$this._topicNames ??= new ListBuilder<String>();
  set topicNames(ListBuilder<String>? topicNames) =>
      _$this._topicNames = topicNames;

  GUpdateTopicsInputBuilder();

  GUpdateTopicsInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _repositoryId = $v.repositoryId;
      _topicNames = $v.topicNames.toBuilder();
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateTopicsInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUpdateTopicsInput;
  }

  @override
  void update(void Function(GUpdateTopicsInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUpdateTopicsInput build() {
    _$GUpdateTopicsInput _$result;
    try {
      _$result = _$v ??
          new _$GUpdateTopicsInput._(
              clientMutationId: clientMutationId,
              repositoryId: BuiltValueNullFieldError.checkNotNull(
                  repositoryId, 'GUpdateTopicsInput', 'repositoryId'),
              topicNames: topicNames.build());
    } catch (_) {
      late String _$failedField;
      try {
        _$failedField = 'topicNames';
        topicNames.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdateTopicsInput', _$failedField, e.toString());
      }
      rethrow;
    }
    replace(_$result);
    return _$result;
  }
}

class _$GUserStatusOrder extends GUserStatusOrder {
  @override
  final GOrderDirection direction;
  @override
  final GUserStatusOrderField field;

  factory _$GUserStatusOrder(
          [void Function(GUserStatusOrderBuilder)? updates]) =>
      (new GUserStatusOrderBuilder()..update(updates)).build();

  _$GUserStatusOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GUserStatusOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(field, 'GUserStatusOrder', 'field');
  }

  @override
  GUserStatusOrder rebuild(void Function(GUserStatusOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GUserStatusOrderBuilder toBuilder() =>
      new GUserStatusOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GUserStatusOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GUserStatusOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GUserStatusOrderBuilder
    implements Builder<GUserStatusOrder, GUserStatusOrderBuilder> {
  _$GUserStatusOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GUserStatusOrderField? _field;
  GUserStatusOrderField? get field => _$this._field;
  set field(GUserStatusOrderField? field) => _$this._field = field;

  GUserStatusOrderBuilder();

  GUserStatusOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUserStatusOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GUserStatusOrder;
  }

  @override
  void update(void Function(GUserStatusOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GUserStatusOrder build() {
    final _$result = _$v ??
        new _$GUserStatusOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GUserStatusOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GUserStatusOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GVerifiableDomainOrder extends GVerifiableDomainOrder {
  @override
  final GOrderDirection direction;
  @override
  final GVerifiableDomainOrderField field;

  factory _$GVerifiableDomainOrder(
          [void Function(GVerifiableDomainOrderBuilder)? updates]) =>
      (new GVerifiableDomainOrderBuilder()..update(updates)).build();

  _$GVerifiableDomainOrder._({required this.direction, required this.field})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        direction, 'GVerifiableDomainOrder', 'direction');
    BuiltValueNullFieldError.checkNotNull(
        field, 'GVerifiableDomainOrder', 'field');
  }

  @override
  GVerifiableDomainOrder rebuild(
          void Function(GVerifiableDomainOrderBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GVerifiableDomainOrderBuilder toBuilder() =>
      new GVerifiableDomainOrderBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GVerifiableDomainOrder &&
        direction == other.direction &&
        field == other.field;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, direction.hashCode), field.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GVerifiableDomainOrder')
          ..add('direction', direction)
          ..add('field', field))
        .toString();
  }
}

class GVerifiableDomainOrderBuilder
    implements Builder<GVerifiableDomainOrder, GVerifiableDomainOrderBuilder> {
  _$GVerifiableDomainOrder? _$v;

  GOrderDirection? _direction;
  GOrderDirection? get direction => _$this._direction;
  set direction(GOrderDirection? direction) => _$this._direction = direction;

  GVerifiableDomainOrderField? _field;
  GVerifiableDomainOrderField? get field => _$this._field;
  set field(GVerifiableDomainOrderField? field) => _$this._field = field;

  GVerifiableDomainOrderBuilder();

  GVerifiableDomainOrderBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _direction = $v.direction;
      _field = $v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GVerifiableDomainOrder other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GVerifiableDomainOrder;
  }

  @override
  void update(void Function(GVerifiableDomainOrderBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GVerifiableDomainOrder build() {
    final _$result = _$v ??
        new _$GVerifiableDomainOrder._(
            direction: BuiltValueNullFieldError.checkNotNull(
                direction, 'GVerifiableDomainOrder', 'direction'),
            field: BuiltValueNullFieldError.checkNotNull(
                field, 'GVerifiableDomainOrder', 'field'));
    replace(_$result);
    return _$result;
  }
}

class _$GVerifyVerifiableDomainInput extends GVerifyVerifiableDomainInput {
  @override
  final String? clientMutationId;
  @override
  final String id;

  factory _$GVerifyVerifiableDomainInput(
          [void Function(GVerifyVerifiableDomainInputBuilder)? updates]) =>
      (new GVerifyVerifiableDomainInputBuilder()..update(updates)).build();

  _$GVerifyVerifiableDomainInput._({this.clientMutationId, required this.id})
      : super._() {
    BuiltValueNullFieldError.checkNotNull(
        id, 'GVerifyVerifiableDomainInput', 'id');
  }

  @override
  GVerifyVerifiableDomainInput rebuild(
          void Function(GVerifyVerifiableDomainInputBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GVerifyVerifiableDomainInputBuilder toBuilder() =>
      new GVerifyVerifiableDomainInputBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GVerifyVerifiableDomainInput &&
        clientMutationId == other.clientMutationId &&
        id == other.id;
  }

  @override
  int get hashCode {
    return $jf($jc($jc(0, clientMutationId.hashCode), id.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GVerifyVerifiableDomainInput')
          ..add('clientMutationId', clientMutationId)
          ..add('id', id))
        .toString();
  }
}

class GVerifyVerifiableDomainInputBuilder
    implements
        Builder<GVerifyVerifiableDomainInput,
            GVerifyVerifiableDomainInputBuilder> {
  _$GVerifyVerifiableDomainInput? _$v;

  String? _clientMutationId;
  String? get clientMutationId => _$this._clientMutationId;
  set clientMutationId(String? clientMutationId) =>
      _$this._clientMutationId = clientMutationId;

  String? _id;
  String? get id => _$this._id;
  set id(String? id) => _$this._id = id;

  GVerifyVerifiableDomainInputBuilder();

  GVerifyVerifiableDomainInputBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _clientMutationId = $v.clientMutationId;
      _id = $v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GVerifyVerifiableDomainInput other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GVerifyVerifiableDomainInput;
  }

  @override
  void update(void Function(GVerifyVerifiableDomainInputBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GVerifyVerifiableDomainInput build() {
    final _$result = _$v ??
        new _$GVerifyVerifiableDomainInput._(
            clientMutationId: clientMutationId,
            id: BuiltValueNullFieldError.checkNotNull(
                id, 'GVerifyVerifiableDomainInput', 'id'));
    replace(_$result);
    return _$result;
  }
}

class _$GX509Certificate extends GX509Certificate {
  @override
  final String value;

  factory _$GX509Certificate(
          [void Function(GX509CertificateBuilder)? updates]) =>
      (new GX509CertificateBuilder()..update(updates)).build();

  _$GX509Certificate._({required this.value}) : super._() {
    BuiltValueNullFieldError.checkNotNull(value, 'GX509Certificate', 'value');
  }

  @override
  GX509Certificate rebuild(void Function(GX509CertificateBuilder) updates) =>
      (toBuilder()..update(updates)).build();

  @override
  GX509CertificateBuilder toBuilder() =>
      new GX509CertificateBuilder()..replace(this);

  @override
  bool operator ==(Object other) {
    if (identical(other, this)) return true;
    return other is GX509Certificate && value == other.value;
  }

  @override
  int get hashCode {
    return $jf($jc(0, value.hashCode));
  }

  @override
  String toString() {
    return (newBuiltValueToStringHelper('GX509Certificate')
          ..add('value', value))
        .toString();
  }
}

class GX509CertificateBuilder
    implements Builder<GX509Certificate, GX509CertificateBuilder> {
  _$GX509Certificate? _$v;

  String? _value;
  String? get value => _$this._value;
  set value(String? value) => _$this._value = value;

  GX509CertificateBuilder();

  GX509CertificateBuilder get _$this {
    final $v = _$v;
    if ($v != null) {
      _value = $v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GX509Certificate other) {
    ArgumentError.checkNotNull(other, 'other');
    _$v = other as _$GX509Certificate;
  }

  @override
  void update(void Function(GX509CertificateBuilder)? updates) {
    if (updates != null) updates(this);
  }

  @override
  _$GX509Certificate build() {
    final _$result = _$v ??
        new _$GX509Certificate._(
            value: BuiltValueNullFieldError.checkNotNull(
                value, 'GX509Certificate', 'value'));
    replace(_$result);
    return _$result;
  }
}

// ignore_for_file: always_put_control_body_on_new_line,always_specify_types,annotate_overrides,avoid_annotating_with_dynamic,avoid_as,avoid_catches_without_on_clauses,avoid_returning_this,lines_longer_than_80_chars,omit_local_variable_types,prefer_expression_function_bodies,sort_constructors_first,test_types_in_equals,unnecessary_const,unnecessary_new