// 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 _$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 '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,
  _$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 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 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');

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;
    default:
      throw new ArgumentError(name);
  }
}

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

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 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 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 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
    _$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 '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,
  _$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 _$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 'QUEUED':
      return _$gRequestableCheckStatusStateQUEUED;
    case 'WAITING':
      return _$gRequestableCheckStatusStateWAITING;
    default:
      throw new ArgumentError(name);
  }
}

final BuiltSet<GRequestableCheckStatusState>
    _$gRequestableCheckStatusStateValues = new BuiltSet<
        GRequestableCheckStatusState>(const <GRequestableCheckStatusState>[
  _$gRequestableCheckStatusStateCOMPLETED,
  _$gRequestableCheckStatusStateIN_PROGRESS,
  _$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 _$gSearchTypeISSUE = const GSearchType._('ISSUE');
const GSearchType _$gSearchTypeREPOSITORY = const GSearchType._('REPOSITORY');
const GSearchType _$gSearchTypeUSER = const GSearchType._('USER');

GSearchType _$gSearchTypeValueOf(String name) {
  switch (name) {
    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>[
  _$gSearchTypeISSUE,
  _$gSearchTypeREPOSITORY,
  _$gSearchTypeUSER,
]);

const GSecurityAdvisoryEcosystem _$gSecurityAdvisoryEcosystemCOMPOSER =
    const GSecurityAdvisoryEcosystem._('COMPOSER');
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 '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,
  _$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 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,
]);

Serializer<GAcceptEnterpriseAdministratorInvitationInput>
    _$gAcceptEnterpriseAdministratorInvitationInputSerializer =
    new _$GAcceptEnterpriseAdministratorInvitationInputSerializer();
Serializer<GAcceptTopicSuggestionInput>
    _$gAcceptTopicSuggestionInputSerializer =
    new _$GAcceptTopicSuggestionInputSerializer();
Serializer<GAddAssigneesToAssignableInput>
    _$gAddAssigneesToAssignableInputSerializer =
    new _$GAddAssigneesToAssignableInputSerializer();
Serializer<GAddCommentInput> _$gAddCommentInputSerializer =
    new _$GAddCommentInputSerializer();
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<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<GContributionOrder> _$gContributionOrderSerializer =
    new _$GContributionOrderSerializer();
Serializer<GConvertProjectCardNoteToIssueInput>
    _$gConvertProjectCardNoteToIssueInputSerializer =
    new _$GConvertProjectCardNoteToIssueInputSerializer();
Serializer<GCreateBranchProtectionRuleInput>
    _$gCreateBranchProtectionRuleInputSerializer =
    new _$GCreateBranchProtectionRuleInputSerializer();
Serializer<GCreateCheckRunInput> _$gCreateCheckRunInputSerializer =
    new _$GCreateCheckRunInputSerializer();
Serializer<GCreateCheckSuiteInput> _$gCreateCheckSuiteInputSerializer =
    new _$GCreateCheckSuiteInputSerializer();
Serializer<GCreateEnterpriseOrganizationInput>
    _$gCreateEnterpriseOrganizationInputSerializer =
    new _$GCreateEnterpriseOrganizationInputSerializer();
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<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<GDeploymentOrder> _$gDeploymentOrderSerializer =
    new _$GDeploymentOrderSerializer();
Serializer<GDeploymentOrderField> _$gDeploymentOrderFieldSerializer =
    new _$GDeploymentOrderFieldSerializer();
Serializer<GDeploymentState> _$gDeploymentStateSerializer =
    new _$GDeploymentStateSerializer();
Serializer<GDeploymentStatusState> _$gDeploymentStatusStateSerializer =
    new _$GDeploymentStatusStateSerializer();
Serializer<GDiffSide> _$gDiffSideSerializer = new _$GDiffSideSerializer();
Serializer<GDismissPullRequestReviewInput>
    _$gDismissPullRequestReviewInputSerializer =
    new _$GDismissPullRequestReviewInputSerializer();
Serializer<GDraftPullRequestReviewComment>
    _$gDraftPullRequestReviewCommentSerializer =
    new _$GDraftPullRequestReviewCommentSerializer();
Serializer<GDraftPullRequestReviewThread>
    _$gDraftPullRequestReviewThreadSerializer =
    new _$GDraftPullRequestReviewThreadSerializer();
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<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<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<GPinnableItemType> _$gPinnableItemTypeSerializer =
    new _$GPinnableItemTypeSerializer();
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<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<GRemoveLabelsFromLabelableInput>
    _$gRemoveLabelsFromLabelableInputSerializer =
    new _$GRemoveLabelsFromLabelableInputSerializer();
Serializer<GRemoveOutsideCollaboratorInput>
    _$gRemoveOutsideCollaboratorInputSerializer =
    new _$GRemoveOutsideCollaboratorInputSerializer();
Serializer<GRemoveReactionInput> _$gRemoveReactionInputSerializer =
    new _$GRemoveReactionInputSerializer();
Serializer<GRemoveStarInput> _$gRemoveStarInputSerializer =
    new _$GRemoveStarInputSerializer();
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<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<GUnmarkFileAsViewedInput> _$gUnmarkFileAsViewedInputSerializer =
    new _$GUnmarkFileAsViewedInputSerializer();
Serializer<GUnmarkIssueAsDuplicateInput>
    _$gUnmarkIssueAsDuplicateInputSerializer =
    new _$GUnmarkIssueAsDuplicateInputSerializer();
Serializer<GUnminimizeCommentInput> _$gUnminimizeCommentInputSerializer =
    new _$GUnminimizeCommentInputSerializer();
Serializer<GUnresolveReviewThreadInput>
    _$gUnresolveReviewThreadInputSerializer =
    new _$GUnresolveReviewThreadInputSerializer();
Serializer<GUpdateBranchProtectionRuleInput>
    _$gUpdateBranchProtectionRuleInputSerializer =
    new _$GUpdateBranchProtectionRuleInputSerializer();
Serializer<GUpdateCheckRunInput> _$gUpdateCheckRunInputSerializer =
    new _$GUpdateCheckRunInputSerializer();
Serializer<GUpdateCheckSuitePreferencesInput>
    _$gUpdateCheckSuitePreferencesInputSerializer =
    new _$GUpdateCheckSuitePreferencesInputSerializer();
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<GUpdateIpAllowListEnabledSettingInput>
    _$gUpdateIpAllowListEnabledSettingInputSerializer =
    new _$GUpdateIpAllowListEnabledSettingInputSerializer();
Serializer<GUpdateIpAllowListEntryInput>
    _$gUpdateIpAllowListEntryInputSerializer =
    new _$GUpdateIpAllowListEntryInputSerializer();
Serializer<GUpdateIssueCommentInput> _$gUpdateIssueCommentInputSerializer =
    new _$GUpdateIssueCommentInputSerializer();
Serializer<GUpdateIssueInput> _$gUpdateIssueInputSerializer =
    new _$GUpdateIssueInputSerializer();
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();

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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)])),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.contentId != null) {
      result
        ..add('contentId')
        ..add(serializers.serialize(object.contentId,
            specifiedType: const FullType(String)));
    }
    if (object.note != null) {
      result
        ..add('note')
        ..add(serializers.serialize(object.note,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.commitOID != null) {
      result
        ..add('commitOID')
        ..add(serializers.serialize(object.commitOID,
            specifiedType: const FullType(String)));
    }
    if (object.inReplyTo != null) {
      result
        ..add('inReplyTo')
        ..add(serializers.serialize(object.inReplyTo,
            specifiedType: const FullType(String)));
    }
    if (object.path != null) {
      result
        ..add('path')
        ..add(serializers.serialize(object.path,
            specifiedType: const FullType(String)));
    }
    if (object.position != null) {
      result
        ..add('position')
        ..add(serializers.serialize(object.position,
            specifiedType: const FullType(int)));
    }
    if (object.pullRequestId != null) {
      result
        ..add('pullRequestId')
        ..add(serializers.serialize(object.pullRequestId,
            specifiedType: const FullType(String)));
    }
    if (object.pullRequestReviewId != null) {
      result
        ..add('pullRequestReviewId')
        ..add(serializers.serialize(object.pullRequestReviewId,
            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 dynamic 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)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.comments != null) {
      result
        ..add('comments')
        ..add(serializers.serialize(object.comments,
            specifiedType: const FullType(BuiltList,
                const [const FullType(GDraftPullRequestReviewComment)])));
    }
    if (object.commitOID != null) {
      result
        ..add('commitOID')
        ..add(serializers.serialize(object.commitOID,
            specifiedType: const FullType(String)));
    }
    if (object.event != null) {
      result
        ..add('event')
        ..add(serializers.serialize(object.event,
            specifiedType: const FullType(GPullRequestReviewEvent)));
    }
    if (object.threads != null) {
      result
        ..add('threads')
        ..add(serializers.serialize(object.threads,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.pullRequestId != null) {
      result
        ..add('pullRequestId')
        ..add(serializers.serialize(object.pullRequestId,
            specifiedType: const FullType(String)));
    }
    if (object.pullRequestReviewId != null) {
      result
        ..add('pullRequestReviewId')
        ..add(serializers.serialize(object.pullRequestReviewId,
            specifiedType: const FullType(String)));
    }
    if (object.side != null) {
      result
        ..add('side')
        ..add(serializers.serialize(object.side,
            specifiedType: const FullType(GDiffSide)));
    }
    if (object.startLine != null) {
      result
        ..add('startLine')
        ..add(serializers.serialize(object.startLine,
            specifiedType: const FullType(int)));
    }
    if (object.startSide != null) {
      result
        ..add('startSide')
        ..add(serializers.serialize(object.startSide,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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>[];
    if (object.direction != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(object.direction,
            specifiedType: const FullType(GOrderDirection)));
    }
    if (object.field != null) {
      result
        ..add('field')
        ..add(serializers.serialize(object.field,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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>[];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.emoji != null) {
      result
        ..add('emoji')
        ..add(serializers.serialize(object.emoji,
            specifiedType: const FullType(String)));
    }
    if (object.expiresAt != null) {
      result
        ..add('expiresAt')
        ..add(serializers.serialize(object.expiresAt,
            specifiedType: const FullType(DateTime)));
    }
    if (object.limitedAvailability != null) {
      result
        ..add('limitedAvailability')
        ..add(serializers.serialize(object.limitedAvailability,
            specifiedType: const FullType(bool)));
    }
    if (object.message != null) {
      result
        ..add('message')
        ..add(serializers.serialize(object.message,
            specifiedType: const FullType(String)));
    }
    if (object.organizationId != null) {
      result
        ..add('organizationId')
        ..add(serializers.serialize(object.organizationId,
            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 dynamic 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)),
    ];
    if (object.rawDetails != null) {
      result
        ..add('rawDetails')
        ..add(serializers.serialize(object.rawDetails,
            specifiedType: const FullType(String)));
    }
    if (object.title != null) {
      result
        ..add('title')
        ..add(serializers.serialize(object.title,
            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 dynamic 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)),
    ];
    if (object.endColumn != null) {
      result
        ..add('endColumn')
        ..add(serializers.serialize(object.endColumn,
            specifiedType: const FullType(int)));
    }
    if (object.startColumn != null) {
      result
        ..add('startColumn')
        ..add(serializers.serialize(object.startColumn,
            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 dynamic 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 dynamic 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>[];
    if (object.appId != null) {
      result
        ..add('appId')
        ..add(serializers.serialize(object.appId,
            specifiedType: const FullType(int)));
    }
    if (object.checkName != null) {
      result
        ..add('checkName')
        ..add(serializers.serialize(object.checkName,
            specifiedType: const FullType(String)));
    }
    if (object.checkType != null) {
      result
        ..add('checkType')
        ..add(serializers.serialize(object.checkType,
            specifiedType: const FullType(GCheckRunType)));
    }
    if (object.status != null) {
      result
        ..add('status')
        ..add(serializers.serialize(object.status,
            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 dynamic 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>[
      'annotations',
      serializers.serialize(object.annotations,
          specifiedType: const FullType(
              BuiltList, const [const FullType(GCheckAnnotationData)])),
      'images',
      serializers.serialize(object.images,
          specifiedType: const FullType(
              BuiltList, const [const FullType(GCheckRunOutputImage)])),
      'summary',
      serializers.serialize(object.summary,
          specifiedType: const FullType(String)),
      'title',
      serializers.serialize(object.title,
          specifiedType: const FullType(String)),
    ];
    if (object.text != null) {
      result
        ..add('text')
        ..add(serializers.serialize(object.text,
            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 dynamic 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)),
    ];
    if (object.caption != null) {
      result
        ..add('caption')
        ..add(serializers.serialize(object.caption,
            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 dynamic 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 dynamic 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>[];
    if (object.appId != null) {
      result
        ..add('appId')
        ..add(serializers.serialize(object.appId,
            specifiedType: const FullType(int)));
    }
    if (object.checkName != null) {
      result
        ..add('checkName')
        ..add(serializers.serialize(object.checkName,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.public != null) {
      result
        ..add('public')
        ..add(serializers.serialize(object.public,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.description != null) {
      result
        ..add('description')
        ..add(serializers.serialize(object.description,
            specifiedType: const FullType(String)));
    }
    if (object.includeAllBranches != null) {
      result
        ..add('includeAllBranches')
        ..add(serializers.serialize(object.includeAllBranches,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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>[
      'emails',
      serializers.serialize(object.emails,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    if (object.id != null) {
      result
        ..add('id')
        ..add(serializers.serialize(object.id,
            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 dynamic 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 dynamic 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 _$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 dynamic 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)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.title != null) {
      result
        ..add('title')
        ..add(serializers.serialize(object.title,
            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 dynamic 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 _$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)),
      'pushActorIds',
      serializers.serialize(object.pushActorIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
      'requiredStatusCheckContexts',
      serializers.serialize(object.requiredStatusCheckContexts,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'reviewDismissalActorIds',
      serializers.serialize(object.reviewDismissalActorIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    if (object.allowsDeletions != null) {
      result
        ..add('allowsDeletions')
        ..add(serializers.serialize(object.allowsDeletions,
            specifiedType: const FullType(bool)));
    }
    if (object.allowsForcePushes != null) {
      result
        ..add('allowsForcePushes')
        ..add(serializers.serialize(object.allowsForcePushes,
            specifiedType: const FullType(bool)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.dismissesStaleReviews != null) {
      result
        ..add('dismissesStaleReviews')
        ..add(serializers.serialize(object.dismissesStaleReviews,
            specifiedType: const FullType(bool)));
    }
    if (object.isAdminEnforced != null) {
      result
        ..add('isAdminEnforced')
        ..add(serializers.serialize(object.isAdminEnforced,
            specifiedType: const FullType(bool)));
    }
    if (object.requiredApprovingReviewCount != null) {
      result
        ..add('requiredApprovingReviewCount')
        ..add(serializers.serialize(object.requiredApprovingReviewCount,
            specifiedType: const FullType(int)));
    }
    if (object.requiresApprovingReviews != null) {
      result
        ..add('requiresApprovingReviews')
        ..add(serializers.serialize(object.requiresApprovingReviews,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresCodeOwnerReviews != null) {
      result
        ..add('requiresCodeOwnerReviews')
        ..add(serializers.serialize(object.requiresCodeOwnerReviews,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresCommitSignatures != null) {
      result
        ..add('requiresCommitSignatures')
        ..add(serializers.serialize(object.requiresCommitSignatures,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresLinearHistory != null) {
      result
        ..add('requiresLinearHistory')
        ..add(serializers.serialize(object.requiresLinearHistory,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresStatusChecks != null) {
      result
        ..add('requiresStatusChecks')
        ..add(serializers.serialize(object.requiresStatusChecks,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresStrictStatusChecks != null) {
      result
        ..add('requiresStrictStatusChecks')
        ..add(serializers.serialize(object.requiresStrictStatusChecks,
            specifiedType: const FullType(bool)));
    }
    if (object.restrictsPushes != null) {
      result
        ..add('restrictsPushes')
        ..add(serializers.serialize(object.restrictsPushes,
            specifiedType: const FullType(bool)));
    }
    if (object.restrictsReviewDismissals != null) {
      result
        ..add('restrictsReviewDismissals')
        ..add(serializers.serialize(object.restrictsReviewDismissals,
            specifiedType: const FullType(bool)));
    }
    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 dynamic 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>[
      'actions',
      serializers.serialize(object.actions,
          specifiedType: const FullType(
              BuiltList, const [const FullType(GCheckRunAction)])),
      '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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.completedAt != null) {
      result
        ..add('completedAt')
        ..add(serializers.serialize(object.completedAt,
            specifiedType: const FullType(DateTime)));
    }
    if (object.conclusion != null) {
      result
        ..add('conclusion')
        ..add(serializers.serialize(object.conclusion,
            specifiedType: const FullType(GCheckConclusionState)));
    }
    if (object.detailsUrl != null) {
      result
        ..add('detailsUrl')
        ..add(serializers.serialize(object.detailsUrl,
            specifiedType: const FullType(String)));
    }
    if (object.externalId != null) {
      result
        ..add('externalId')
        ..add(serializers.serialize(object.externalId,
            specifiedType: const FullType(String)));
    }
    if (object.output != null) {
      result
        ..add('output')
        ..add(serializers.serialize(object.output,
            specifiedType: const FullType(GCheckRunOutput)));
    }
    if (object.startedAt != null) {
      result
        ..add('startedAt')
        ..add(serializers.serialize(object.startedAt,
            specifiedType: const FullType(DateTime)));
    }
    if (object.status != null) {
      result
        ..add('status')
        ..add(serializers.serialize(object.status,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.name != null) {
      result
        ..add('name')
        ..add(serializers.serialize(object.name,
            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 dynamic 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>[
      'assigneeIds',
      serializers.serialize(object.assigneeIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'labelIds',
      serializers.serialize(object.labelIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'projectIds',
      serializers.serialize(object.projectIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
      'title',
      serializers.serialize(object.title,
          specifiedType: const FullType(String)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.issueTemplate != null) {
      result
        ..add('issueTemplate')
        ..add(serializers.serialize(object.issueTemplate,
            specifiedType: const FullType(String)));
    }
    if (object.milestoneId != null) {
      result
        ..add('milestoneId')
        ..add(serializers.serialize(object.milestoneId,
            specifiedType: 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 dynamic 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)),
      'repositoryIds',
      serializers.serialize(object.repositoryIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.template != null) {
      result
        ..add('template')
        ..add(serializers.serialize(object.template,
            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 dynamic 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)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.draft != null) {
      result
        ..add('draft')
        ..add(serializers.serialize(object.draft,
            specifiedType: const FullType(bool)));
    }
    if (object.maintainerCanModify != null) {
      result
        ..add('maintainerCanModify')
        ..add(serializers.serialize(object.maintainerCanModify,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.description != null) {
      result
        ..add('description')
        ..add(serializers.serialize(object.description,
            specifiedType: const FullType(String)));
    }
    if (object.hasIssuesEnabled != null) {
      result
        ..add('hasIssuesEnabled')
        ..add(serializers.serialize(object.hasIssuesEnabled,
            specifiedType: const FullType(bool)));
    }
    if (object.hasWikiEnabled != null) {
      result
        ..add('hasWikiEnabled')
        ..add(serializers.serialize(object.hasWikiEnabled,
            specifiedType: const FullType(bool)));
    }
    if (object.homepageUrl != null) {
      result
        ..add('homepageUrl')
        ..add(serializers.serialize(object.homepageUrl,
            specifiedType: const FullType(String)));
    }
    if (object.ownerId != null) {
      result
        ..add('ownerId')
        ..add(serializers.serialize(object.ownerId,
            specifiedType: const FullType(String)));
    }
    if (object.teamId != null) {
      result
        ..add('teamId')
        ..add(serializers.serialize(object.teamId,
            specifiedType: const FullType(String)));
    }
    if (object.template != null) {
      result
        ..add('template')
        ..add(serializers.serialize(object.template,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.private != null) {
      result
        ..add('private')
        ..add(serializers.serialize(object.private,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 dynamic 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 _$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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 dynamic 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)),
    ];
    if (object.side != null) {
      result
        ..add('side')
        ..add(serializers.serialize(object.side,
            specifiedType: const FullType(GDiffSide)));
    }
    if (object.startLine != null) {
      result
        ..add('startLine')
        ..add(serializers.serialize(object.startLine,
            specifiedType: const FullType(int)));
    }
    if (object.startSide != null) {
      result
        ..add('startSide')
        ..add(serializers.serialize(object.startSide,
            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 dynamic 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 _$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 dynamic 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 dynamic 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 dynamic 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 dynamic 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 dynamic 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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.email != null) {
      result
        ..add('email')
        ..add(serializers.serialize(object.email,
            specifiedType: const FullType(String)));
    }
    if (object.invitee != null) {
      result
        ..add('invitee')
        ..add(serializers.serialize(object.invitee,
            specifiedType: const FullType(String)));
    }
    if (object.role != null) {
      result
        ..add('role')
        ..add(serializers.serialize(object.role,
            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 dynamic 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 dynamic 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 dynamic 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>[
      'labels',
      serializers.serialize(object.labels,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'states',
      serializers.serialize(object.states,
          specifiedType:
              const FullType(BuiltList, const [const FullType(GIssueState)])),
    ];
    if (object.assignee != null) {
      result
        ..add('assignee')
        ..add(serializers.serialize(object.assignee,
            specifiedType: const FullType(String)));
    }
    if (object.createdBy != null) {
      result
        ..add('createdBy')
        ..add(serializers.serialize(object.createdBy,
            specifiedType: const FullType(String)));
    }
    if (object.mentioned != null) {
      result
        ..add('mentioned')
        ..add(serializers.serialize(object.mentioned,
            specifiedType: const FullType(String)));
    }
    if (object.milestone != null) {
      result
        ..add('milestone')
        ..add(serializers.serialize(object.milestone,
            specifiedType: const FullType(String)));
    }
    if (object.since != null) {
      result
        ..add('since')
        ..add(serializers.serialize(object.since,
            specifiedType: const FullType(DateTime)));
    }
    if (object.viewerSubscribed != null) {
      result
        ..add('viewerSubscribed')
        ..add(serializers.serialize(object.viewerSubscribed,
            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 dynamic 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 dynamic 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 dynamic 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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.lockReason != null) {
      result
        ..add('lockReason')
        ..add(serializers.serialize(object.lockReason,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.authorEmail != null) {
      result
        ..add('authorEmail')
        ..add(serializers.serialize(object.authorEmail,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.commitMessage != null) {
      result
        ..add('commitMessage')
        ..add(serializers.serialize(object.commitMessage,
            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 dynamic 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)),
    ];
    if (object.authorEmail != null) {
      result
        ..add('authorEmail')
        ..add(serializers.serialize(object.authorEmail,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.commitBody != null) {
      result
        ..add('commitBody')
        ..add(serializers.serialize(object.commitBody,
            specifiedType: const FullType(String)));
    }
    if (object.commitHeadline != null) {
      result
        ..add('commitHeadline')
        ..add(serializers.serialize(object.commitHeadline,
            specifiedType: const FullType(String)));
    }
    if (object.expectedHeadOid != null) {
      result
        ..add('expectedHeadOid')
        ..add(serializers.serialize(object.expectedHeadOid,
            specifiedType: const FullType(String)));
    }
    if (object.mergeMethod != null) {
      result
        ..add('mergeMethod')
        ..add(serializers.serialize(object.mergeMethod,
            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 dynamic 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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.afterCardId != null) {
      result
        ..add('afterCardId')
        ..add(serializers.serialize(object.afterCardId,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.afterColumnId != null) {
      result
        ..add('afterColumnId')
        ..add(serializers.serialize(object.afterColumnId,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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 dynamic 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>[];
    if (object.direction != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(object.direction,
            specifiedType: const FullType(GOrderDirection)));
    }
    if (object.field != null) {
      result
        ..add('field')
        ..add(serializers.serialize(object.field,
            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 dynamic 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>[];
    if (object.direction != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(object.direction,
            specifiedType: const FullType(GOrderDirection)));
    }
    if (object.field != null) {
      result
        ..add('field')
        ..add(serializers.serialize(object.field,
            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 dynamic 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>[];
    if (object.direction != null) {
      result
        ..add('direction')
        ..add(serializers.serialize(object.direction,
            specifiedType: const FullType(GOrderDirection)));
    }
    if (object.field != null) {
      result
        ..add('field')
        ..add(serializers.serialize(object.field,
            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 dynamic 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 _$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 _$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 dynamic 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 dynamic 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 dynamic 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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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 dynamic 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)])),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 dynamic 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 dynamic 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)),
      'teamIds',
      serializers.serialize(object.teamIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'userIds',
      serializers.serialize(object.userIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.union != null) {
      result
        ..add('union')
        ..add(serializers.serialize(object.union,
            specifiedType: const FullType(bool)));
    }
    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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 dynamic 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 dynamic 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 dynamic 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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.issuer != null) {
      result
        ..add('issuer')
        ..add(serializers.serialize(object.issuer,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.expiry != null) {
      result
        ..add('expiry')
        ..add(serializers.serialize(object.expiry,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.expiry != null) {
      result
        ..add('expiry')
        ..add(serializers.serialize(object.expiry,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.expiry != null) {
      result
        ..add('expiry')
        ..add(serializers.serialize(object.expiry,
            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 dynamic 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 _$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 dynamic 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 dynamic 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 dynamic 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)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.pullRequestId != null) {
      result
        ..add('pullRequestId')
        ..add(serializers.serialize(object.pullRequestId,
            specifiedType: const FullType(String)));
    }
    if (object.pullRequestReviewId != null) {
      result
        ..add('pullRequestReviewId')
        ..add(serializers.serialize(object.pullRequestReviewId,
            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 dynamic 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 dynamic 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 dynamic 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 dynamic 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 dynamic 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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
      'pushActorIds',
      serializers.serialize(object.pushActorIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'requiredStatusCheckContexts',
      serializers.serialize(object.requiredStatusCheckContexts,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'reviewDismissalActorIds',
      serializers.serialize(object.reviewDismissalActorIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    if (object.allowsDeletions != null) {
      result
        ..add('allowsDeletions')
        ..add(serializers.serialize(object.allowsDeletions,
            specifiedType: const FullType(bool)));
    }
    if (object.allowsForcePushes != null) {
      result
        ..add('allowsForcePushes')
        ..add(serializers.serialize(object.allowsForcePushes,
            specifiedType: const FullType(bool)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.dismissesStaleReviews != null) {
      result
        ..add('dismissesStaleReviews')
        ..add(serializers.serialize(object.dismissesStaleReviews,
            specifiedType: const FullType(bool)));
    }
    if (object.isAdminEnforced != null) {
      result
        ..add('isAdminEnforced')
        ..add(serializers.serialize(object.isAdminEnforced,
            specifiedType: const FullType(bool)));
    }
    if (object.pattern != null) {
      result
        ..add('pattern')
        ..add(serializers.serialize(object.pattern,
            specifiedType: const FullType(String)));
    }
    if (object.requiredApprovingReviewCount != null) {
      result
        ..add('requiredApprovingReviewCount')
        ..add(serializers.serialize(object.requiredApprovingReviewCount,
            specifiedType: const FullType(int)));
    }
    if (object.requiresApprovingReviews != null) {
      result
        ..add('requiresApprovingReviews')
        ..add(serializers.serialize(object.requiresApprovingReviews,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresCodeOwnerReviews != null) {
      result
        ..add('requiresCodeOwnerReviews')
        ..add(serializers.serialize(object.requiresCodeOwnerReviews,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresCommitSignatures != null) {
      result
        ..add('requiresCommitSignatures')
        ..add(serializers.serialize(object.requiresCommitSignatures,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresLinearHistory != null) {
      result
        ..add('requiresLinearHistory')
        ..add(serializers.serialize(object.requiresLinearHistory,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresStatusChecks != null) {
      result
        ..add('requiresStatusChecks')
        ..add(serializers.serialize(object.requiresStatusChecks,
            specifiedType: const FullType(bool)));
    }
    if (object.requiresStrictStatusChecks != null) {
      result
        ..add('requiresStrictStatusChecks')
        ..add(serializers.serialize(object.requiresStrictStatusChecks,
            specifiedType: const FullType(bool)));
    }
    if (object.restrictsPushes != null) {
      result
        ..add('restrictsPushes')
        ..add(serializers.serialize(object.restrictsPushes,
            specifiedType: const FullType(bool)));
    }
    if (object.restrictsReviewDismissals != null) {
      result
        ..add('restrictsReviewDismissals')
        ..add(serializers.serialize(object.restrictsReviewDismissals,
            specifiedType: const FullType(bool)));
    }
    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 dynamic 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>[
      'actions',
      serializers.serialize(object.actions,
          specifiedType: const FullType(
              BuiltList, const [const FullType(GCheckRunAction)])),
      'checkRunId',
      serializers.serialize(object.checkRunId,
          specifiedType: const FullType(String)),
      'repositoryId',
      serializers.serialize(object.repositoryId,
          specifiedType: const FullType(String)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.completedAt != null) {
      result
        ..add('completedAt')
        ..add(serializers.serialize(object.completedAt,
            specifiedType: const FullType(DateTime)));
    }
    if (object.conclusion != null) {
      result
        ..add('conclusion')
        ..add(serializers.serialize(object.conclusion,
            specifiedType: const FullType(GCheckConclusionState)));
    }
    if (object.detailsUrl != null) {
      result
        ..add('detailsUrl')
        ..add(serializers.serialize(object.detailsUrl,
            specifiedType: const FullType(String)));
    }
    if (object.externalId != null) {
      result
        ..add('externalId')
        ..add(serializers.serialize(object.externalId,
            specifiedType: const FullType(String)));
    }
    if (object.name != null) {
      result
        ..add('name')
        ..add(serializers.serialize(object.name,
            specifiedType: const FullType(String)));
    }
    if (object.output != null) {
      result
        ..add('output')
        ..add(serializers.serialize(object.output,
            specifiedType: const FullType(GCheckRunOutput)));
    }
    if (object.startedAt != null) {
      result
        ..add('startedAt')
        ..add(serializers.serialize(object.startedAt,
            specifiedType: const FullType(DateTime)));
    }
    if (object.status != null) {
      result
        ..add('status')
        ..add(serializers.serialize(object.status,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.membersCanCreateInternalRepositories != null) {
      result
        ..add('membersCanCreateInternalRepositories')
        ..add(serializers.serialize(object.membersCanCreateInternalRepositories,
            specifiedType: const FullType(bool)));
    }
    if (object.membersCanCreatePrivateRepositories != null) {
      result
        ..add('membersCanCreatePrivateRepositories')
        ..add(serializers.serialize(object.membersCanCreatePrivateRepositories,
            specifiedType: const FullType(bool)));
    }
    if (object.membersCanCreatePublicRepositories != null) {
      result
        ..add('membersCanCreatePublicRepositories')
        ..add(serializers.serialize(object.membersCanCreatePublicRepositories,
            specifiedType: const FullType(bool)));
    }
    if (object.membersCanCreateRepositoriesPolicyEnabled != null) {
      result
        ..add('membersCanCreateRepositoriesPolicyEnabled')
        ..add(serializers.serialize(
            object.membersCanCreateRepositoriesPolicyEnabled,
            specifiedType: const FullType(bool)));
    }
    if (object.settingValue != null) {
      result
        ..add('settingValue')
        ..add(serializers.serialize(object.settingValue,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.description != null) {
      result
        ..add('description')
        ..add(serializers.serialize(object.description,
            specifiedType: const FullType(String)));
    }
    if (object.location != null) {
      result
        ..add('location')
        ..add(serializers.serialize(object.location,
            specifiedType: const FullType(String)));
    }
    if (object.name != null) {
      result
        ..add('name')
        ..add(serializers.serialize(object.name,
            specifiedType: const FullType(String)));
    }
    if (object.websiteUrl != null) {
      result
        ..add('websiteUrl')
        ..add(serializers.serialize(object.websiteUrl,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.name != null) {
      result
        ..add('name')
        ..add(serializers.serialize(object.name,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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>[
      'assigneeIds',
      serializers.serialize(object.assigneeIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'id',
      serializers.serialize(object.id, specifiedType: const FullType(String)),
      'labelIds',
      serializers.serialize(object.labelIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'projectIds',
      serializers.serialize(object.projectIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.milestoneId != null) {
      result
        ..add('milestoneId')
        ..add(serializers.serialize(object.milestoneId,
            specifiedType: const FullType(String)));
    }
    if (object.state != null) {
      result
        ..add('state')
        ..add(serializers.serialize(object.state,
            specifiedType: const FullType(GIssueState)));
    }
    if (object.title != null) {
      result
        ..add('title')
        ..add(serializers.serialize(object.title,
            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 dynamic 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 _$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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.isArchived != null) {
      result
        ..add('isArchived')
        ..add(serializers.serialize(object.isArchived,
            specifiedType: const FullType(bool)));
    }
    if (object.note != null) {
      result
        ..add('note')
        ..add(serializers.serialize(object.note,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.name != null) {
      result
        ..add('name')
        ..add(serializers.serialize(object.name,
            specifiedType: const FullType(String)));
    }
    if (object.public != null) {
      result
        ..add('public')
        ..add(serializers.serialize(object.public,
            specifiedType: const FullType(bool)));
    }
    if (object.state != null) {
      result
        ..add('state')
        ..add(serializers.serialize(object.state,
            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 dynamic 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>[
      'assigneeIds',
      serializers.serialize(object.assigneeIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'labelIds',
      serializers.serialize(object.labelIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'projectIds',
      serializers.serialize(object.projectIds,
          specifiedType:
              const FullType(BuiltList, const [const FullType(String)])),
      'pullRequestId',
      serializers.serialize(object.pullRequestId,
          specifiedType: const FullType(String)),
    ];
    if (object.baseRefName != null) {
      result
        ..add('baseRefName')
        ..add(serializers.serialize(object.baseRefName,
            specifiedType: const FullType(String)));
    }
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.maintainerCanModify != null) {
      result
        ..add('maintainerCanModify')
        ..add(serializers.serialize(object.maintainerCanModify,
            specifiedType: const FullType(bool)));
    }
    if (object.milestoneId != null) {
      result
        ..add('milestoneId')
        ..add(serializers.serialize(object.milestoneId,
            specifiedType: const FullType(String)));
    }
    if (object.state != null) {
      result
        ..add('state')
        ..add(serializers.serialize(object.state,
            specifiedType: const FullType(GPullRequestUpdateState)));
    }
    if (object.title != null) {
      result
        ..add('title')
        ..add(serializers.serialize(object.title,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.force != null) {
      result
        ..add('force')
        ..add(serializers.serialize(object.force,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.description != null) {
      result
        ..add('description')
        ..add(serializers.serialize(object.description,
            specifiedType: const FullType(String)));
    }
    if (object.hasIssuesEnabled != null) {
      result
        ..add('hasIssuesEnabled')
        ..add(serializers.serialize(object.hasIssuesEnabled,
            specifiedType: const FullType(bool)));
    }
    if (object.hasProjectsEnabled != null) {
      result
        ..add('hasProjectsEnabled')
        ..add(serializers.serialize(object.hasProjectsEnabled,
            specifiedType: const FullType(bool)));
    }
    if (object.hasWikiEnabled != null) {
      result
        ..add('hasWikiEnabled')
        ..add(serializers.serialize(object.hasWikiEnabled,
            specifiedType: const FullType(bool)));
    }
    if (object.homepageUrl != null) {
      result
        ..add('homepageUrl')
        ..add(serializers.serialize(object.homepageUrl,
            specifiedType: const FullType(String)));
    }
    if (object.name != null) {
      result
        ..add('name')
        ..add(serializers.serialize(object.name,
            specifiedType: const FullType(String)));
    }
    if (object.template != null) {
      result
        ..add('template')
        ..add(serializers.serialize(object.template,
            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 dynamic 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)),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.bodyVersion != null) {
      result
        ..add('bodyVersion')
        ..add(serializers.serialize(object.bodyVersion,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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)),
    ];
    if (object.body != null) {
      result
        ..add('body')
        ..add(serializers.serialize(object.body,
            specifiedType: const FullType(String)));
    }
    if (object.bodyVersion != null) {
      result
        ..add('bodyVersion')
        ..add(serializers.serialize(object.bodyVersion,
            specifiedType: const FullType(String)));
    }
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            specifiedType: const FullType(String)));
    }
    if (object.pinned != null) {
      result
        ..add('pinned')
        ..add(serializers.serialize(object.pinned,
            specifiedType: const FullType(bool)));
    }
    if (object.title != null) {
      result
        ..add('title')
        ..add(serializers.serialize(object.title,
            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 dynamic 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)])),
    ];
    if (object.clientMutationId != null) {
      result
        ..add('clientMutationId')
        ..add(serializers.serialize(object.clientMutationId,
            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 dynamic 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 dynamic 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 _$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, this.invitationId})
      : super._() {
    if (invitationId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _invitationId = _$v.invitationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAcceptEnterpriseAdministratorInvitationInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.name, this.repositoryId})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError('GAcceptTopicSuggestionInput', 'name');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _name = _$v.name;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAcceptTopicSuggestionInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
            repositoryId: 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._(
      {this.assignableId, this.assigneeIds, this.clientMutationId})
      : super._() {
    if (assignableId == null) {
      throw new BuiltValueNullFieldError(
          'GAddAssigneesToAssignableInput', 'assignableId');
    }
    if (assigneeIds == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _assignableId = _$v.assignableId;
      _assigneeIds = _$v.assigneeIds?.toBuilder();
      _clientMutationId = _$v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddAssigneesToAssignableInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: assignableId,
              assigneeIds: assigneeIds.build(),
              clientMutationId: clientMutationId);
    } catch (_) {
      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._({this.body, this.clientMutationId, this.subjectId})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError('GAddCommentInput', 'body');
    }
    if (subjectId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _body = _$v.body;
      _clientMutationId = _$v.clientMutationId;
      _subjectId = _$v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            clientMutationId: clientMutationId,
            subjectId: subjectId);
    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, this.labelIds, this.labelableId})
      : super._() {
    if (labelIds == null) {
      throw new BuiltValueNullFieldError(
          'GAddLabelsToLabelableInput', 'labelIds');
    }
    if (labelableId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _labelIds = _$v.labelIds?.toBuilder();
      _labelableId = _$v.labelableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddLabelsToLabelableInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: labelableId);
    } catch (_) {
      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, this.projectColumnId})
      : super._() {
    if (projectColumnId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _contentId = _$v.contentId;
      _note = _$v.note;
      _projectColumnId = _$v.projectColumnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddProjectCardInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.name, this.projectId})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError('GAddProjectColumnInput', 'name');
    }
    if (projectId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _name = _$v.name;
      _projectId = _$v.projectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddProjectColumnInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
            projectId: 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._(
      {this.body,
      this.clientMutationId,
      this.commitOID,
      this.inReplyTo,
      this.path,
      this.position,
      this.pullRequestId,
      this.pullRequestReviewId})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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,
      this.pullRequestId,
      this.threads})
      : super._() {
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: pullRequestId,
              threads: _threads?.build());
    } catch (_) {
      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._(
      {this.body,
      this.clientMutationId,
      this.line,
      this.path,
      this.pullRequestId,
      this.pullRequestReviewId,
      this.side,
      this.startLine,
      this.startSide})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          'GAddPullRequestReviewThreadInput', 'body');
    }
    if (line == null) {
      throw new BuiltValueNullFieldError(
          'GAddPullRequestReviewThreadInput', 'line');
    }
    if (path == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            clientMutationId: clientMutationId,
            line: line,
            path: 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, this.content, this.subjectId})
      : super._() {
    if (content == null) {
      throw new BuiltValueNullFieldError('GAddReactionInput', 'content');
    }
    if (subjectId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _content = _$v.content;
      _subjectId = _$v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddReactionInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: content,
            subjectId: 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, this.starrableId}) : super._() {
    if (starrableId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _starrableId = _$v.starrableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAddStarInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: starrableId);
    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, this.repositoryId})
      : super._() {
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GArchiveRepositoryInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GAuditLogOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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, this.invitationId})
      : super._() {
    if (invitationId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _invitationId = _$v.invitationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCancelEnterpriseAdminInvitationInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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._(
      {this.annotationLevel,
      this.location,
      this.message,
      this.path,
      this.rawDetails,
      this.title})
      : super._() {
    if (annotationLevel == null) {
      throw new BuiltValueNullFieldError(
          'GCheckAnnotationData', 'annotationLevel');
    }
    if (location == null) {
      throw new BuiltValueNullFieldError('GCheckAnnotationData', 'location');
    }
    if (message == null) {
      throw new BuiltValueNullFieldError('GCheckAnnotationData', 'message');
    }
    if (path == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: annotationLevel,
              location: location.build(),
              message: message,
              path: path,
              rawDetails: rawDetails,
              title: title);
    } catch (_) {
      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, this.endLine, this.startColumn, this.startLine})
      : super._() {
    if (endLine == null) {
      throw new BuiltValueNullFieldError('GCheckAnnotationRange', 'endLine');
    }
    if (startLine == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _endColumn = _$v.endColumn;
      _endLine = _$v.endLine;
      _startColumn = _$v.startColumn;
      _startLine = _$v.startLine;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckAnnotationRange other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: endLine,
            startColumn: startColumn,
            startLine: 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._({this.description, this.identifier, this.label})
      : super._() {
    if (description == null) {
      throw new BuiltValueNullFieldError('GCheckRunAction', 'description');
    }
    if (identifier == null) {
      throw new BuiltValueNullFieldError('GCheckRunAction', 'identifier');
    }
    if (label == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _description = _$v.description;
      _identifier = _$v.identifier;
      _label = _$v.label;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckRunAction other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: description, identifier: identifier, label: 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 {
    if (_$v != null) {
      _appId = _$v.appId;
      _checkName = _$v.checkName;
      _checkType = _$v.checkType;
      _status = _$v.status;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckRunFilter other) {
    if (other == null) {
      throw new ArgumentError.notNull('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, this.summary, this.text, this.title})
      : super._() {
    if (annotations == null) {
      throw new BuiltValueNullFieldError('GCheckRunOutput', 'annotations');
    }
    if (images == null) {
      throw new BuiltValueNullFieldError('GCheckRunOutput', 'images');
    }
    if (summary == null) {
      throw new BuiltValueNullFieldError('GCheckRunOutput', 'summary');
    }
    if (title == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: summary,
              text: text,
              title: title);
    } catch (_) {
      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._({this.alt, this.caption, this.imageUrl})
      : super._() {
    if (alt == null) {
      throw new BuiltValueNullFieldError('GCheckRunOutputImage', 'alt');
    }
    if (imageUrl == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _alt = _$v.alt;
      _caption = _$v.caption;
      _imageUrl = _$v.imageUrl;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckRunOutputImage other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: alt, caption: caption, imageUrl: 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._({this.appId, this.setting}) : super._() {
    if (appId == null) {
      throw new BuiltValueNullFieldError(
          'GCheckSuiteAutoTriggerPreference', 'appId');
    }
    if (setting == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _appId = _$v.appId;
      _setting = _$v.setting;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckSuiteAutoTriggerPreference other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: appId, setting: 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 {
    if (_$v != null) {
      _appId = _$v.appId;
      _checkName = _$v.checkName;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCheckSuiteFilter other) {
    if (other == null) {
      throw new ArgumentError.notNull('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, this.labelableId})
      : super._() {
    if (labelableId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _labelableId = _$v.labelableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GClearLabelsFromLabelableInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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,
      this.includeWorkflows,
      this.name,
      this.public,
      this.sourceId,
      this.targetOwnerId})
      : super._() {
    if (includeWorkflows == null) {
      throw new BuiltValueNullFieldError(
          'GCloneProjectInput', 'includeWorkflows');
    }
    if (name == null) {
      throw new BuiltValueNullFieldError('GCloneProjectInput', 'name');
    }
    if (sourceId == null) {
      throw new BuiltValueNullFieldError('GCloneProjectInput', 'sourceId');
    }
    if (targetOwnerId == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: includeWorkflows,
            name: name,
            public: public,
            sourceId: sourceId,
            targetOwnerId: 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,
      this.name,
      this.ownerId,
      this.repositoryId,
      this.visibility})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError(
          'GCloneTemplateRepositoryInput', 'name');
    }
    if (ownerId == null) {
      throw new BuiltValueNullFieldError(
          'GCloneTemplateRepositoryInput', 'ownerId');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          'GCloneTemplateRepositoryInput', 'repositoryId');
    }
    if (visibility == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
            ownerId: ownerId,
            repositoryId: repositoryId,
            visibility: 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, this.issueId}) : super._() {
    if (issueId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _issueId = _$v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCloseIssueInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.pullRequestId})
      : super._() {
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _pullRequestId = _$v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GClosePullRequestInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._() {
    if (emails == null) {
      throw new BuiltValueNullFieldError('GCommitAuthor', 'emails');
    }
  }

  @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 {
    if (_$v != null) {
      _emails = _$v.emails?.toBuilder();
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCommitAuthor other) {
    if (other == null) {
      throw new ArgumentError.notNull('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 (_) {
      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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GCommitContributionOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCommitContributionOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GContributionOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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,
      this.projectCardId,
      this.repositoryId,
      this.title})
      : super._() {
    if (projectCardId == null) {
      throw new BuiltValueNullFieldError(
          'GConvertProjectCardNoteToIssueInput', 'projectCardId');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: projectCardId,
            repositoryId: repositoryId,
            title: title);
    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,
      this.pattern,
      this.pushActorIds,
      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._() {
    if (pattern == null) {
      throw new BuiltValueNullFieldError(
          'GCreateBranchProtectionRuleInput', 'pattern');
    }
    if (pushActorIds == null) {
      throw new BuiltValueNullFieldError(
          'GCreateBranchProtectionRuleInput', 'pushActorIds');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          'GCreateBranchProtectionRuleInput', 'repositoryId');
    }
    if (requiredStatusCheckContexts == null) {
      throw new BuiltValueNullFieldError(
          'GCreateBranchProtectionRuleInput', 'requiredStatusCheckContexts');
    }
    if (reviewDismissalActorIds == null) {
      throw new BuiltValueNullFieldError(
          'GCreateBranchProtectionRuleInput', 'reviewDismissalActorIds');
    }
  }

  @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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: pattern,
              pushActorIds: pushActorIds.build(),
              repositoryId: 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 (_) {
      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,
      this.headSha,
      this.name,
      this.output,
      this.repositoryId,
      this.startedAt,
      this.status})
      : super._() {
    if (actions == null) {
      throw new BuiltValueNullFieldError('GCreateCheckRunInput', 'actions');
    }
    if (headSha == null) {
      throw new BuiltValueNullFieldError('GCreateCheckRunInput', 'headSha');
    }
    if (name == null) {
      throw new BuiltValueNullFieldError('GCreateCheckRunInput', 'name');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: headSha,
              name: name,
              output: _output?.build(),
              repositoryId: repositoryId,
              startedAt: startedAt,
              status: status);
    } catch (_) {
      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, this.headSha, this.repositoryId})
      : super._() {
    if (headSha == null) {
      throw new BuiltValueNullFieldError('GCreateCheckSuiteInput', 'headSha');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _headSha = _$v.headSha;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateCheckSuiteInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: headSha,
            repositoryId: repositoryId);
    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._(
      {this.adminLogins,
      this.billingEmail,
      this.clientMutationId,
      this.enterpriseId,
      this.login,
      this.profileName})
      : super._() {
    if (adminLogins == null) {
      throw new BuiltValueNullFieldError(
          'GCreateEnterpriseOrganizationInput', 'adminLogins');
    }
    if (billingEmail == null) {
      throw new BuiltValueNullFieldError(
          'GCreateEnterpriseOrganizationInput', 'billingEmail');
    }
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GCreateEnterpriseOrganizationInput', 'enterpriseId');
    }
    if (login == null) {
      throw new BuiltValueNullFieldError(
          'GCreateEnterpriseOrganizationInput', 'login');
    }
    if (profileName == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: billingEmail,
              clientMutationId: clientMutationId,
              enterpriseId: enterpriseId,
              login: login,
              profileName: profileName);
    } catch (_) {
      String _$failedField;
      try {
        _$failedField = 'adminLogins';
        adminLogins.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GCreateEnterpriseOrganizationInput', _$failedField, e.toString());
      }
      rethrow;
    }
    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._(
      {this.allowListValue,
      this.clientMutationId,
      this.isActive,
      this.name,
      this.ownerId})
      : super._() {
    if (allowListValue == null) {
      throw new BuiltValueNullFieldError(
          'GCreateIpAllowListEntryInput', 'allowListValue');
    }
    if (isActive == null) {
      throw new BuiltValueNullFieldError(
          'GCreateIpAllowListEntryInput', 'isActive');
    }
    if (ownerId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: allowListValue,
            clientMutationId: clientMutationId,
            isActive: isActive,
            name: name,
            ownerId: 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,
      this.repositoryId,
      this.title})
      : super._() {
    if (assigneeIds == null) {
      throw new BuiltValueNullFieldError('GCreateIssueInput', 'assigneeIds');
    }
    if (labelIds == null) {
      throw new BuiltValueNullFieldError('GCreateIssueInput', 'labelIds');
    }
    if (projectIds == null) {
      throw new BuiltValueNullFieldError('GCreateIssueInput', 'projectIds');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError('GCreateIssueInput', 'repositoryId');
    }
    if (title == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: repositoryId,
              title: title);
    } catch (_) {
      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,
      this.name,
      this.ownerId,
      this.repositoryIds,
      this.template})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError('GCreateProjectInput', 'name');
    }
    if (ownerId == null) {
      throw new BuiltValueNullFieldError('GCreateProjectInput', 'ownerId');
    }
    if (repositoryIds == null) {
      throw new BuiltValueNullFieldError(
          'GCreateProjectInput', 'repositoryIds');
    }
  }

  @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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
              ownerId: ownerId,
              repositoryIds: repositoryIds.build(),
              template: template);
    } catch (_) {
      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._(
      {this.baseRefName,
      this.body,
      this.clientMutationId,
      this.draft,
      this.headRefName,
      this.maintainerCanModify,
      this.repositoryId,
      this.title})
      : super._() {
    if (baseRefName == null) {
      throw new BuiltValueNullFieldError(
          'GCreatePullRequestInput', 'baseRefName');
    }
    if (headRefName == null) {
      throw new BuiltValueNullFieldError(
          'GCreatePullRequestInput', 'headRefName');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          'GCreatePullRequestInput', 'repositoryId');
    }
    if (title == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: baseRefName,
            body: body,
            clientMutationId: clientMutationId,
            draft: draft,
            headRefName: headRefName,
            maintainerCanModify: maintainerCanModify,
            repositoryId: repositoryId,
            title: 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, this.name, this.oid, this.repositoryId})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError('GCreateRefInput', 'name');
    }
    if (oid == null) {
      throw new BuiltValueNullFieldError('GCreateRefInput', 'oid');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _name = _$v.name;
      _oid = _$v.oid;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateRefInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
            oid: oid,
            repositoryId: 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,
      this.name,
      this.ownerId,
      this.teamId,
      this.template,
      this.visibility})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError('GCreateRepositoryInput', 'name');
    }
    if (visibility == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
            ownerId: ownerId,
            teamId: teamId,
            template: template,
            visibility: 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._(
      {this.body, this.clientMutationId, this.discussionId})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          'GCreateTeamDiscussionCommentInput', 'body');
    }
    if (discussionId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _body = _$v.body;
      _clientMutationId = _$v.clientMutationId;
      _discussionId = _$v.discussionId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GCreateTeamDiscussionCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            clientMutationId: clientMutationId,
            discussionId: 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._(
      {this.body, this.clientMutationId, this.private, this.teamId, this.title})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError('GCreateTeamDiscussionInput', 'body');
    }
    if (teamId == null) {
      throw new BuiltValueNullFieldError(
          'GCreateTeamDiscussionInput', 'teamId');
    }
    if (title == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            clientMutationId: clientMutationId,
            private: private,
            teamId: teamId,
            title: 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._({this.value}) : super._() {
    if (value == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _value = _$v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDate other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.name, this.reason, this.repositoryId})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError(
          'GDeclineTopicSuggestionInput', 'name');
    }
    if (reason == null) {
      throw new BuiltValueNullFieldError(
          'GDeclineTopicSuggestionInput', 'reason');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _name = _$v.name;
      _reason = _$v.reason;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeclineTopicSuggestionInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
            reason: reason,
            repositoryId: 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._(
      {this.branchProtectionRuleId, this.clientMutationId})
      : super._() {
    if (branchProtectionRuleId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _branchProtectionRuleId = _$v.branchProtectionRuleId;
      _clientMutationId = _$v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteBranchProtectionRuleInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.id}) : super._() {
    if (id == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteDeploymentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.ipAllowListEntryId})
      : super._() {
    if (ipAllowListEntryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _ipAllowListEntryId = _$v.ipAllowListEntryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteIpAllowListEntryInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.id}) : super._() {
    if (id == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteIssueCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.issueId}) : super._() {
    if (issueId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _issueId = _$v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteIssueInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.cardId, this.clientMutationId})
      : super._() {
    if (cardId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _cardId = _$v.cardId;
      _clientMutationId = _$v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteProjectCardInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.columnId})
      : super._() {
    if (columnId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _columnId = _$v.columnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteProjectColumnInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.projectId}) : super._() {
    if (projectId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _projectId = _$v.projectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteProjectInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.id})
      : super._() {
    if (id == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeletePullRequestReviewCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.pullRequestReviewId})
      : super._() {
    if (pullRequestReviewId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _pullRequestReviewId = _$v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeletePullRequestReviewInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.refId}) : super._() {
    if (refId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _refId = _$v.refId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteRefInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.id})
      : super._() {
    if (id == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteTeamDiscussionCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.id}) : super._() {
    if (id == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeleteTeamDiscussionInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GDeploymentOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDeploymentOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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, this.message, this.pullRequestReviewId})
      : super._() {
    if (message == null) {
      throw new BuiltValueNullFieldError(
          'GDismissPullRequestReviewInput', 'message');
    }
    if (pullRequestReviewId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _message = _$v.message;
      _pullRequestReviewId = _$v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDismissPullRequestReviewInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: message,
            pullRequestReviewId: 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._({this.body, this.path, this.position})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          'GDraftPullRequestReviewComment', 'body');
    }
    if (path == null) {
      throw new BuiltValueNullFieldError(
          'GDraftPullRequestReviewComment', 'path');
    }
    if (position == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _body = _$v.body;
      _path = _$v.path;
      _position = _$v.position;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GDraftPullRequestReviewComment other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body, path: path, position: 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._(
      {this.body,
      this.line,
      this.path,
      this.side,
      this.startLine,
      this.startSide})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          'GDraftPullRequestReviewThread', 'body');
    }
    if (line == null) {
      throw new BuiltValueNullFieldError(
          'GDraftPullRequestReviewThread', 'line');
    }
    if (path == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            line: line,
            path: path,
            side: side,
            startLine: startLine,
            startSide: startSide);
    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._({this.direction, this.field})
      : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GEnterpriseAdministratorInvitationOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseAdministratorInvitationOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GEnterpriseMemberOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseMemberOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field})
      : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GEnterpriseServerInstallationOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerInstallationOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field})
      : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GEnterpriseServerUserAccountEmailOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerUserAccountEmailOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field})
      : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GEnterpriseServerUserAccountOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerUserAccountOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field})
      : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GEnterpriseServerUserAccountsUploadOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GEnterpriseServerUserAccountsUploadOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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, this.userId}) : super._() {
    if (userId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _userId = _$v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GFollowUserInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GGistOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GGistOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.value}) : super._() {
    if (value == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _value = _$v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GGitSSHRemote other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.value}) : super._() {
    if (value == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _value = _$v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GGitTimestamp other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.value}) : super._() {
    if (value == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _value = _$v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GHTML other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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,
      this.enterpriseId,
      this.invitee,
      this.role})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GIpAllowListEntryOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GIpAllowListEntryOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GIssueCommentOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GIssueCommentOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._() {
    if (labels == null) {
      throw new BuiltValueNullFieldError('GIssueFilters', 'labels');
    }
    if (states == null) {
      throw new BuiltValueNullFieldError('GIssueFilters', 'states');
    }
  }

  @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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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 (_) {
      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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GIssueOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GIssueOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GLabelOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLabelOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GLanguageOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLanguageOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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, this.projectId, this.repositoryId})
      : super._() {
    if (projectId == null) {
      throw new BuiltValueNullFieldError(
          'GLinkRepositoryToProjectInput', 'projectId');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _projectId = _$v.projectId;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLinkRepositoryToProjectInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: projectId,
            repositoryId: 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, this.lockableId})
      : super._() {
    if (lockableId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _lockReason = _$v.lockReason;
      _lockableId = _$v.lockableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GLockLockableInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: lockableId);
    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, this.path, this.pullRequestId})
      : super._() {
    if (path == null) {
      throw new BuiltValueNullFieldError('GMarkFileAsViewedInput', 'path');
    }
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _path = _$v.path;
      _pullRequestId = _$v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMarkFileAsViewedInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: path,
            pullRequestId: 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, this.pullRequestId})
      : super._() {
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _pullRequestId = _$v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMarkPullRequestReadyForReviewInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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,
      this.base,
      this.clientMutationId,
      this.commitMessage,
      this.head,
      this.repositoryId})
      : super._() {
    if (base == null) {
      throw new BuiltValueNullFieldError('GMergeBranchInput', 'base');
    }
    if (head == null) {
      throw new BuiltValueNullFieldError('GMergeBranchInput', 'head');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: base,
            clientMutationId: clientMutationId,
            commitMessage: commitMessage,
            head: head,
            repositoryId: 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,
      this.pullRequestId})
      : super._() {
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GMilestoneOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMilestoneOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._(
      {this.classifier, this.clientMutationId, this.subjectId})
      : super._() {
    if (classifier == null) {
      throw new BuiltValueNullFieldError('GMinimizeCommentInput', 'classifier');
    }
    if (subjectId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _classifier = _$v.classifier;
      _clientMutationId = _$v.clientMutationId;
      _subjectId = _$v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMinimizeCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: classifier,
            clientMutationId: clientMutationId,
            subjectId: 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, this.cardId, this.clientMutationId, this.columnId})
      : super._() {
    if (cardId == null) {
      throw new BuiltValueNullFieldError('GMoveProjectCardInput', 'cardId');
    }
    if (columnId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _afterCardId = _$v.afterCardId;
      _cardId = _$v.cardId;
      _clientMutationId = _$v.clientMutationId;
      _columnId = _$v.columnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMoveProjectCardInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: cardId,
            clientMutationId: clientMutationId,
            columnId: 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, this.columnId})
      : super._() {
    if (columnId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _afterColumnId = _$v.afterColumnId;
      _clientMutationId = _$v.clientMutationId;
      _columnId = _$v.columnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GMoveProjectColumnInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GOrganizationOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GOrganizationOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPackageFileOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPackageOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPackageVersionOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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 _$GPreciseDateTime extends GPreciseDateTime {
  @override
  final String value;

  factory _$GPreciseDateTime(
          [void Function(GPreciseDateTimeBuilder) updates]) =>
      (new GPreciseDateTimeBuilder()..update(updates)).build();

  _$GPreciseDateTime._({this.value}) : super._() {
    if (value == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _value = _$v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPreciseDateTime other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GProjectOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GProjectOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GPullRequestOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GPullRequestOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GReactionOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReactionOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GRefOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRefOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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, this.enterpriseId})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRegenerateEnterpriseIdentityProviderRecoveryCodesInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId);
    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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GReleaseOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReleaseOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._(
      {this.assignableId, this.assigneeIds, this.clientMutationId})
      : super._() {
    if (assignableId == null) {
      throw new BuiltValueNullFieldError(
          'GRemoveAssigneesFromAssignableInput', 'assignableId');
    }
    if (assigneeIds == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _assignableId = _$v.assignableId;
      _assigneeIds = _$v.assigneeIds?.toBuilder();
      _clientMutationId = _$v.clientMutationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveAssigneesFromAssignableInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: assignableId,
              assigneeIds: assigneeIds.build(),
              clientMutationId: clientMutationId);
    } catch (_) {
      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, this.enterpriseId, this.login})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GRemoveEnterpriseAdminInput', 'enterpriseId');
    }
    if (login == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _login = _$v.login;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveEnterpriseAdminInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            login: 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, this.enterpriseId})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveEnterpriseIdentityProviderInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.enterpriseId, this.organizationId})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GRemoveEnterpriseOrganizationInput', 'enterpriseId');
    }
    if (organizationId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _organizationId = _$v.organizationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveEnterpriseOrganizationInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            organizationId: organizationId);
    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, this.labelIds, this.labelableId})
      : super._() {
    if (labelIds == null) {
      throw new BuiltValueNullFieldError(
          'GRemoveLabelsFromLabelableInput', 'labelIds');
    }
    if (labelableId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _labelIds = _$v.labelIds?.toBuilder();
      _labelableId = _$v.labelableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveLabelsFromLabelableInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: labelableId);
    } catch (_) {
      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, this.organizationId, this.userId})
      : super._() {
    if (organizationId == null) {
      throw new BuiltValueNullFieldError(
          'GRemoveOutsideCollaboratorInput', 'organizationId');
    }
    if (userId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _organizationId = _$v.organizationId;
      _userId = _$v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveOutsideCollaboratorInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: organizationId,
            userId: 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, this.content, this.subjectId})
      : super._() {
    if (content == null) {
      throw new BuiltValueNullFieldError('GRemoveReactionInput', 'content');
    }
    if (subjectId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _content = _$v.content;
      _subjectId = _$v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveReactionInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: content,
            subjectId: 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, this.starrableId}) : super._() {
    if (starrableId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _starrableId = _$v.starrableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRemoveStarInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: starrableId);
    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, this.issueId}) : super._() {
    if (issueId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _issueId = _$v.issueId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReopenIssueInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.pullRequestId})
      : super._() {
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _pullRequestId = _$v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GReopenPullRequestInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GRepositoryInvitationOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRepositoryInvitationOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GRepositoryOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRepositoryOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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,
      this.pullRequestId,
      this.teamIds,
      this.union,
      this.userIds})
      : super._() {
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          'GRequestReviewsInput', 'pullRequestId');
    }
    if (teamIds == null) {
      throw new BuiltValueNullFieldError('GRequestReviewsInput', 'teamIds');
    }
    if (userIds == null) {
      throw new BuiltValueNullFieldError('GRequestReviewsInput', 'userIds');
    }
  }

  @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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: pullRequestId,
              teamIds: teamIds.build(),
              union: union,
              userIds: userIds.build());
    } catch (_) {
      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._(
      {this.checkSuiteId, this.clientMutationId, this.repositoryId})
      : super._() {
    if (checkSuiteId == null) {
      throw new BuiltValueNullFieldError(
          'GRerequestCheckSuiteInput', 'checkSuiteId');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _checkSuiteId = _$v.checkSuiteId;
      _clientMutationId = _$v.clientMutationId;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GRerequestCheckSuiteInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: checkSuiteId,
            clientMutationId: clientMutationId,
            repositoryId: 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, this.threadId})
      : super._() {
    if (threadId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _threadId = _$v.threadId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GResolveReviewThreadInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GSavedReplyOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSavedReplyOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.type, this.value}) : super._() {
    if (type == null) {
      throw new BuiltValueNullFieldError(
          'GSecurityAdvisoryIdentifierFilter', 'type');
    }
    if (value == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _type = _$v.type;
      _value = _$v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSecurityAdvisoryIdentifierFilter other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: type, value: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GSecurityAdvisoryOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSecurityAdvisoryOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GSecurityVulnerabilityOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSecurityVulnerabilityOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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,
      this.digestMethod,
      this.enterpriseId,
      this.idpCertificate,
      this.issuer,
      this.signatureMethod,
      this.ssoUrl})
      : super._() {
    if (digestMethod == null) {
      throw new BuiltValueNullFieldError(
          'GSetEnterpriseIdentityProviderInput', 'digestMethod');
    }
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GSetEnterpriseIdentityProviderInput', 'enterpriseId');
    }
    if (idpCertificate == null) {
      throw new BuiltValueNullFieldError(
          'GSetEnterpriseIdentityProviderInput', 'idpCertificate');
    }
    if (signatureMethod == null) {
      throw new BuiltValueNullFieldError(
          'GSetEnterpriseIdentityProviderInput', 'signatureMethod');
    }
    if (ssoUrl == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: digestMethod,
            enterpriseId: enterpriseId,
            idpCertificate: idpCertificate,
            issuer: issuer,
            signatureMethod: signatureMethod,
            ssoUrl: 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, this.limit, this.organizationId})
      : super._() {
    if (limit == null) {
      throw new BuiltValueNullFieldError(
          'GSetOrganizationInteractionLimitInput', 'limit');
    }
    if (organizationId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _expiry = _$v.expiry;
      _limit = _$v.limit;
      _organizationId = _$v.organizationId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSetOrganizationInteractionLimitInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: limit,
            organizationId: 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, this.limit, this.repositoryId})
      : super._() {
    if (limit == null) {
      throw new BuiltValueNullFieldError(
          'GSetRepositoryInteractionLimitInput', 'limit');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _expiry = _$v.expiry;
      _limit = _$v.limit;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSetRepositoryInteractionLimitInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: limit,
            repositoryId: 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, this.limit, this.userId})
      : super._() {
    if (limit == null) {
      throw new BuiltValueNullFieldError(
          'GSetUserInteractionLimitInput', 'limit');
    }
    if (userId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _expiry = _$v.expiry;
      _limit = _$v.limit;
      _userId = _$v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSetUserInteractionLimitInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: limit,
            userId: userId);
    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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GSponsorsTierOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSponsorsTierOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GSponsorshipOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GSponsorshipOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GStarOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GStarOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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,
      this.event,
      this.pullRequestId,
      this.pullRequestReviewId})
      : super._() {
    if (event == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError(
          'GTeamDiscussionCommentOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamDiscussionCommentOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GTeamDiscussionOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamDiscussionOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GTeamMemberOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamMemberOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GTeamOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GTeamRepositoryOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTeamRepositoryOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: 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, this.issueId, this.repositoryId})
      : super._() {
    if (issueId == null) {
      throw new BuiltValueNullFieldError('GTransferIssueInput', 'issueId');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _issueId = _$v.issueId;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GTransferIssueInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: issueId,
            repositoryId: 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, this.repositoryId})
      : super._() {
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnarchiveRepositoryInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.userId}) : super._() {
    if (userId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _userId = _$v.userId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnfollowUserInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.projectId, this.repositoryId})
      : super._() {
    if (projectId == null) {
      throw new BuiltValueNullFieldError(
          'GUnlinkRepositoryFromProjectInput', 'projectId');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _projectId = _$v.projectId;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnlinkRepositoryFromProjectInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: projectId,
            repositoryId: 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, this.lockableId})
      : super._() {
    if (lockableId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _lockableId = _$v.lockableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnlockLockableInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: lockableId);
    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, this.path, this.pullRequestId})
      : super._() {
    if (path == null) {
      throw new BuiltValueNullFieldError('GUnmarkFileAsViewedInput', 'path');
    }
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _path = _$v.path;
      _pullRequestId = _$v.pullRequestId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnmarkFileAsViewedInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: path,
            pullRequestId: 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._(
      {this.canonicalId, this.clientMutationId, this.duplicateId})
      : super._() {
    if (canonicalId == null) {
      throw new BuiltValueNullFieldError(
          'GUnmarkIssueAsDuplicateInput', 'canonicalId');
    }
    if (duplicateId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _canonicalId = _$v.canonicalId;
      _clientMutationId = _$v.clientMutationId;
      _duplicateId = _$v.duplicateId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnmarkIssueAsDuplicateInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: canonicalId,
            clientMutationId: clientMutationId,
            duplicateId: 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, this.subjectId})
      : super._() {
    if (subjectId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _subjectId = _$v.subjectId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnminimizeCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: subjectId);
    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, this.threadId})
      : super._() {
    if (threadId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _threadId = _$v.threadId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUnresolveReviewThreadInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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,
      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._() {
    if (branchProtectionRuleId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateBranchProtectionRuleInput', 'branchProtectionRuleId');
    }
    if (pushActorIds == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateBranchProtectionRuleInput', 'pushActorIds');
    }
    if (requiredStatusCheckContexts == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateBranchProtectionRuleInput', 'requiredStatusCheckContexts');
    }
    if (reviewDismissalActorIds == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateBranchProtectionRuleInput', 'reviewDismissalActorIds');
    }
  }

  @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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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 (_) {
      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,
      this.checkRunId,
      this.clientMutationId,
      this.completedAt,
      this.conclusion,
      this.detailsUrl,
      this.externalId,
      this.name,
      this.output,
      this.repositoryId,
      this.startedAt,
      this.status})
      : super._() {
    if (actions == null) {
      throw new BuiltValueNullFieldError('GUpdateCheckRunInput', 'actions');
    }
    if (checkRunId == null) {
      throw new BuiltValueNullFieldError('GUpdateCheckRunInput', 'checkRunId');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: checkRunId,
              clientMutationId: clientMutationId,
              completedAt: completedAt,
              conclusion: conclusion,
              detailsUrl: detailsUrl,
              externalId: externalId,
              name: name,
              output: _output?.build(),
              repositoryId: repositoryId,
              startedAt: startedAt,
              status: status);
    } catch (_) {
      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._(
      {this.autoTriggerPreferences, this.clientMutationId, this.repositoryId})
      : super._() {
    if (autoTriggerPreferences == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateCheckSuitePreferencesInput', 'autoTriggerPreferences');
    }
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _autoTriggerPreferences = _$v.autoTriggerPreferences?.toBuilder();
      _clientMutationId = _$v.clientMutationId;
      _repositoryId = _$v.repositoryId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateCheckSuitePreferencesInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: repositoryId);
    } catch (_) {
      String _$failedField;
      try {
        _$failedField = 'autoTriggerPreferences';
        autoTriggerPreferences.build();
      } catch (e) {
        throw new BuiltValueNestedFieldError(
            'GUpdateCheckSuitePreferencesInput', _$failedField, e.toString());
      }
      rethrow;
    }
    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, this.enterpriseId, this.login, this.role})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseAdministratorRoleInput', 'enterpriseId');
    }
    if (login == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseAdministratorRoleInput', 'login');
    }
    if (role == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _login = _$v.login;
      _role = _$v.role;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseAdministratorRoleInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            login: login,
            role: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseAllowPrivateRepositoryForkingSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseDefaultRepositoryPermissionSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseDefaultRepositoryPermissionSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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,
      this.enterpriseId,
      this.membersCanCreateInternalRepositories,
      this.membersCanCreatePrivateRepositories,
      this.membersCanCreatePublicRepositories,
      this.membersCanCreateRepositoriesPolicyEnabled,
      this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseMembersCanDeleteIssuesSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseMembersCanDeleteIssuesSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanDeleteRepositoriesSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanInviteCollaboratorsSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseMembersCanMakePurchasesSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseMembersCanMakePurchasesSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseMembersCanViewDependencyInsightsSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseOrganizationProjectsSettingInput', 'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseOrganizationProjectsSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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,
      this.enterpriseId,
      this.location,
      this.name,
      this.websiteUrl})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseRepositoryProjectsSettingInput', 'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseRepositoryProjectsSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseTeamDiscussionsSettingInput', 'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateEnterpriseTeamDiscussionsSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: 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, this.enterpriseId, this.settingValue})
      : super._() {
    if (enterpriseId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput',
          'enterpriseId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _enterpriseId = _$v.enterpriseId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(
      GUpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: enterpriseId,
            settingValue: settingValue);
    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, this.ownerId, this.settingValue})
      : super._() {
    if (ownerId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateIpAllowListEnabledSettingInput', 'ownerId');
    }
    if (settingValue == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _ownerId = _$v.ownerId;
      _settingValue = _$v.settingValue;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateIpAllowListEnabledSettingInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: ownerId,
            settingValue: 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._(
      {this.allowListValue,
      this.clientMutationId,
      this.ipAllowListEntryId,
      this.isActive,
      this.name})
      : super._() {
    if (allowListValue == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateIpAllowListEntryInput', 'allowListValue');
    }
    if (ipAllowListEntryId == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateIpAllowListEntryInput', 'ipAllowListEntryId');
    }
    if (isActive == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: allowListValue,
            clientMutationId: clientMutationId,
            ipAllowListEntryId: ipAllowListEntryId,
            isActive: 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._({this.body, this.clientMutationId, this.id})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError('GUpdateIssueCommentInput', 'body');
    }
    if (id == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _body = _$v.body;
      _clientMutationId = _$v.clientMutationId;
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateIssueCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body, clientMutationId: clientMutationId, id: 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,
      this.id,
      this.labelIds,
      this.milestoneId,
      this.projectIds,
      this.state,
      this.title})
      : super._() {
    if (assigneeIds == null) {
      throw new BuiltValueNullFieldError('GUpdateIssueInput', 'assigneeIds');
    }
    if (id == null) {
      throw new BuiltValueNullFieldError('GUpdateIssueInput', 'id');
    }
    if (labelIds == null) {
      throw new BuiltValueNullFieldError('GUpdateIssueInput', 'labelIds');
    }
    if (projectIds == null) {
      throw new BuiltValueNullFieldError('GUpdateIssueInput', 'projectIds');
    }
  }

  @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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: id,
              labelIds: labelIds.build(),
              milestoneId: milestoneId,
              projectIds: projectIds.build(),
              state: state,
              title: title);
    } catch (_) {
      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 _$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, this.projectCardId})
      : super._() {
    if (projectCardId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _isArchived = _$v.isArchived;
      _note = _$v.note;
      _projectCardId = _$v.projectCardId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateProjectCardInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.name, this.projectColumnId})
      : super._() {
    if (name == null) {
      throw new BuiltValueNullFieldError('GUpdateProjectColumnInput', 'name');
    }
    if (projectColumnId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _name = _$v.name;
      _projectColumnId = _$v.projectColumnId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateProjectColumnInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: name,
            projectColumnId: 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,
      this.projectId,
      this.public,
      this.state})
      : super._() {
    if (projectId == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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,
      this.pullRequestId,
      this.state,
      this.title})
      : super._() {
    if (assigneeIds == null) {
      throw new BuiltValueNullFieldError(
          'GUpdatePullRequestInput', 'assigneeIds');
    }
    if (labelIds == null) {
      throw new BuiltValueNullFieldError('GUpdatePullRequestInput', 'labelIds');
    }
    if (projectIds == null) {
      throw new BuiltValueNullFieldError(
          'GUpdatePullRequestInput', 'projectIds');
    }
    if (pullRequestId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: pullRequestId,
              state: state,
              title: title);
    } catch (_) {
      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._(
      {this.body, this.clientMutationId, this.pullRequestReviewCommentId})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          'GUpdatePullRequestReviewCommentInput', 'body');
    }
    if (pullRequestReviewCommentId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _body = _$v.body;
      _clientMutationId = _$v.clientMutationId;
      _pullRequestReviewCommentId = _$v.pullRequestReviewCommentId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdatePullRequestReviewCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            clientMutationId: clientMutationId,
            pullRequestReviewCommentId: 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._(
      {this.body, this.clientMutationId, this.pullRequestReviewId})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          'GUpdatePullRequestReviewInput', 'body');
    }
    if (pullRequestReviewId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _body = _$v.body;
      _clientMutationId = _$v.clientMutationId;
      _pullRequestReviewId = _$v.pullRequestReviewId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdatePullRequestReviewInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            clientMutationId: clientMutationId,
            pullRequestReviewId: 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, this.oid, this.refId})
      : super._() {
    if (oid == null) {
      throw new BuiltValueNullFieldError('GUpdateRefInput', 'oid');
    }
    if (refId == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _force = _$v.force;
      _oid = _$v.oid;
      _refId = _$v.refId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateRefInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: oid,
            refId: 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,
      this.repositoryId,
      this.template})
      : super._() {
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.state, this.subscribableId})
      : super._() {
    if (state == null) {
      throw new BuiltValueNullFieldError('GUpdateSubscriptionInput', 'state');
    }
    if (subscribableId == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _state = _$v.state;
      _subscribableId = _$v.subscribableId;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateSubscriptionInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: state,
            subscribableId: 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._(
      {this.body, this.bodyVersion, this.clientMutationId, this.id})
      : super._() {
    if (body == null) {
      throw new BuiltValueNullFieldError(
          'GUpdateTeamDiscussionCommentInput', 'body');
    }
    if (id == null) {
      throw new BuiltValueNullFieldError(
          '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 {
    if (_$v != null) {
      _body = _$v.body;
      _bodyVersion = _$v.bodyVersion;
      _clientMutationId = _$v.clientMutationId;
      _id = _$v.id;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateTeamDiscussionCommentInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: body,
            bodyVersion: bodyVersion,
            clientMutationId: clientMutationId,
            id: 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,
      this.id,
      this.pinned,
      this.title})
      : super._() {
    if (id == null) {
      throw new BuiltValueNullFieldError('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 {
    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) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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, this.repositoryId, this.topicNames})
      : super._() {
    if (repositoryId == null) {
      throw new BuiltValueNullFieldError('GUpdateTopicsInput', 'repositoryId');
    }
    if (topicNames == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _clientMutationId = _$v.clientMutationId;
      _repositoryId = _$v.repositoryId;
      _topicNames = _$v.topicNames?.toBuilder();
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUpdateTopicsInput other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: repositoryId,
              topicNames: topicNames.build());
    } catch (_) {
      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._({this.direction, this.field}) : super._() {
    if (direction == null) {
      throw new BuiltValueNullFieldError('GUserStatusOrder', 'direction');
    }
    if (field == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _direction = _$v.direction;
      _field = _$v.field;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GUserStatusOrder other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: direction, field: field);
    replace(_$result);
    return _$result;
  }
}

class _$GX509Certificate extends GX509Certificate {
  @override
  final String value;

  factory _$GX509Certificate(
          [void Function(GX509CertificateBuilder) updates]) =>
      (new GX509CertificateBuilder()..update(updates)).build();

  _$GX509Certificate._({this.value}) : super._() {
    if (value == null) {
      throw new BuiltValueNullFieldError('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 {
    if (_$v != null) {
      _value = _$v.value;
      _$v = null;
    }
    return this;
  }

  @override
  void replace(GX509Certificate other) {
    if (other == null) {
      throw new ArgumentError.notNull('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: 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
