diff --git a/airbyte-config/init/src/main/resources/seed/source_definitions.yaml b/airbyte-config/init/src/main/resources/seed/source_definitions.yaml index 354f79df3b83..417641a0649c 100644 --- a/airbyte-config/init/src/main/resources/seed/source_definitions.yaml +++ b/airbyte-config/init/src/main/resources/seed/source_definitions.yaml @@ -295,7 +295,7 @@ - name: GitHub sourceDefinitionId: ef69ef6e-aa7f-4af1-a01d-ef775033524e dockerRepository: airbyte/source-github - dockerImageTag: 0.2.34 + dockerImageTag: 0.2.35 documentationUrl: https://docs.airbyte.io/integrations/sources/github icon: github.svg sourceType: api diff --git a/airbyte-config/init/src/main/resources/seed/source_specs.yaml b/airbyte-config/init/src/main/resources/seed/source_specs.yaml index 53d36ea61a5d..74c61e4f75f1 100644 --- a/airbyte-config/init/src/main/resources/seed/source_specs.yaml +++ b/airbyte-config/init/src/main/resources/seed/source_specs.yaml @@ -2599,7 +2599,7 @@ supportsNormalization: false supportsDBT: false supported_destination_sync_modes: [] -- dockerImage: "airbyte/source-github:0.2.34" +- dockerImage: "airbyte/source-github:0.2.35" spec: documentationUrl: "https://docs.airbyte.com/integrations/sources/github" connectionSpecification: diff --git a/airbyte-integrations/connectors/source-github/Dockerfile b/airbyte-integrations/connectors/source-github/Dockerfile index caf0cf95bc79..71fbf3ee2ede 100644 --- a/airbyte-integrations/connectors/source-github/Dockerfile +++ b/airbyte-integrations/connectors/source-github/Dockerfile @@ -12,5 +12,5 @@ RUN pip install . ENV AIRBYTE_ENTRYPOINT "python /airbyte/integration_code/main.py" ENTRYPOINT ["python", "/airbyte/integration_code/main.py"] -LABEL io.airbyte.version=0.2.34 +LABEL io.airbyte.version=0.2.35 LABEL io.airbyte.name=airbyte/source-github diff --git a/airbyte-integrations/connectors/source-github/setup.py b/airbyte-integrations/connectors/source-github/setup.py index 2f966207e021..52380693ac32 100644 --- a/airbyte-integrations/connectors/source-github/setup.py +++ b/airbyte-integrations/connectors/source-github/setup.py @@ -5,11 +5,7 @@ from setuptools import find_packages, setup -MAIN_REQUIREMENTS = [ - "airbyte-cdk~=0.1.33", - "vcrpy==4.1.1", - "pendulum~=2.1.2", -] +MAIN_REQUIREMENTS = ["airbyte-cdk~=0.1.33", "vcrpy==4.1.1", "pendulum~=2.1.2", "sgqlc"] TEST_REQUIREMENTS = ["pytest~=6.1", "source-acceptance-test", "responses~=0.19.0"] diff --git a/airbyte-integrations/connectors/source-github/source_github/github_schema.py b/airbyte-integrations/connectors/source-github/source_github/github_schema.py new file mode 100644 index 000000000000..9f223ec59d96 --- /dev/null +++ b/airbyte-integrations/connectors/source-github/source_github/github_schema.py @@ -0,0 +1,34194 @@ +# +# Copyright (c) 2022 Airbyte, Inc., all rights reserved. +# + +import sgqlc.types +import sgqlc.types.datetime +import sgqlc.types.relay + +github_schema = sgqlc.types.Schema() + + +# Unexport Node/PageInfo, let schema re-declare them +github_schema -= sgqlc.types.relay.Node +github_schema -= sgqlc.types.relay.PageInfo + + +__docformat__ = "markdown" + + +######################################################################## +# Scalars and Enumerations +######################################################################## +class ActorType(sgqlc.types.Enum): + """The actor's type. + + Enumeration Choices: + + * `TEAM`: Indicates a team actor. + * `USER`: Indicates a user actor. + """ + + __schema__ = github_schema + __choices__ = ("TEAM", "USER") + + +class AuditLogOrderField(sgqlc.types.Enum): + """Properties by which Audit Log connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order audit log entries by timestamp + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class Base64String(sgqlc.types.Scalar): + """A (potentially binary) string encoded using base64.""" + + __schema__ = github_schema + + +Boolean = sgqlc.types.Boolean + + +class CheckAnnotationLevel(sgqlc.types.Enum): + """Represents an annotation's information level. + + Enumeration Choices: + + * `FAILURE`: An annotation indicating an inescapable error. + * `NOTICE`: An annotation indicating some information. + * `WARNING`: An annotation indicating an ignorable error. + """ + + __schema__ = github_schema + __choices__ = ("FAILURE", "NOTICE", "WARNING") + + +class CheckConclusionState(sgqlc.types.Enum): + """The possible states for a check suite or run conclusion. + + Enumeration Choices: + + * `ACTION_REQUIRED`: The check suite or run requires action. + * `CANCELLED`: The check suite or run has been cancelled. + * `FAILURE`: The check suite or run has failed. + * `NEUTRAL`: The check suite or run was neutral. + * `SKIPPED`: The check suite or run was skipped. + * `STALE`: The check suite or run was marked stale by GitHub. Only + GitHub can use this conclusion. + * `STARTUP_FAILURE`: The check suite or run has failed at startup. + * `SUCCESS`: The check suite or run has succeeded. + * `TIMED_OUT`: The check suite or run has timed out. + """ + + __schema__ = github_schema + __choices__ = ("ACTION_REQUIRED", "CANCELLED", "FAILURE", "NEUTRAL", "SKIPPED", "STALE", "STARTUP_FAILURE", "SUCCESS", "TIMED_OUT") + + +class CheckRunType(sgqlc.types.Enum): + """The possible types of check runs. + + Enumeration Choices: + + * `ALL`: Every check run available. + * `LATEST`: The latest check run. + """ + + __schema__ = github_schema + __choices__ = ("ALL", "LATEST") + + +class CheckStatusState(sgqlc.types.Enum): + """The possible states for a check suite or run status. + + Enumeration Choices: + + * `COMPLETED`: The check suite or run has been completed. + * `IN_PROGRESS`: The check suite or run is in progress. + * `PENDING`: The check suite or run is in pending state. + * `QUEUED`: The check suite or run has been queued. + * `REQUESTED`: The check suite or run has been requested. + * `WAITING`: The check suite or run is in waiting state. + """ + + __schema__ = github_schema + __choices__ = ("COMPLETED", "IN_PROGRESS", "PENDING", "QUEUED", "REQUESTED", "WAITING") + + +class CollaboratorAffiliation(sgqlc.types.Enum): + """Collaborators affiliation level with a subject. + + Enumeration Choices: + + * `ALL`: All collaborators the authenticated user can see. + * `DIRECT`: All collaborators with permissions to an organization- + owned subject, regardless of organization membership status. + * `OUTSIDE`: All outside collaborators of an organization-owned + subject. + """ + + __schema__ = github_schema + __choices__ = ("ALL", "DIRECT", "OUTSIDE") + + +class CommentAuthorAssociation(sgqlc.types.Enum): + """A comment author association with repository. + + Enumeration Choices: + + * `COLLABORATOR`: Author has been invited to collaborate on the + repository. + * `CONTRIBUTOR`: Author has previously committed to the + repository. + * `FIRST_TIMER`: Author has not previously committed to GitHub. + * `FIRST_TIME_CONTRIBUTOR`: Author has not previously committed to + the repository. + * `MANNEQUIN`: Author is a placeholder for an unclaimed user. + * `MEMBER`: Author is a member of the organization that owns the + repository. + * `NONE`: Author has no association with the repository. + * `OWNER`: Author is the owner of the repository. + """ + + __schema__ = github_schema + __choices__ = ("COLLABORATOR", "CONTRIBUTOR", "FIRST_TIMER", "FIRST_TIME_CONTRIBUTOR", "MANNEQUIN", "MEMBER", "NONE", "OWNER") + + +class CommentCannotUpdateReason(sgqlc.types.Enum): + """The possible errors that will prevent a user from updating a + comment. + + Enumeration Choices: + + * `ARCHIVED`: Unable to create comment because repository is + archived. + * `DENIED`: You cannot update this comment + * `INSUFFICIENT_ACCESS`: You must be the author or have write + access to this repository to update this comment. + * `LOCKED`: Unable to create comment because issue is locked. + * `LOGIN_REQUIRED`: You must be logged in to update this comment. + * `MAINTENANCE`: Repository is under maintenance. + * `VERIFIED_EMAIL_REQUIRED`: At least one email address must be + verified to update this comment. + """ + + __schema__ = github_schema + __choices__ = ("ARCHIVED", "DENIED", "INSUFFICIENT_ACCESS", "LOCKED", "LOGIN_REQUIRED", "MAINTENANCE", "VERIFIED_EMAIL_REQUIRED") + + +class CommitContributionOrderField(sgqlc.types.Enum): + """Properties by which commit contribution connections can be + ordered. + + Enumeration Choices: + + * `COMMIT_COUNT`: Order commit contributions by how many commits + they represent. + * `OCCURRED_AT`: Order commit contributions by when they were + made. + """ + + __schema__ = github_schema + __choices__ = ("COMMIT_COUNT", "OCCURRED_AT") + + +class ContributionLevel(sgqlc.types.Enum): + """Varying levels of contributions from none to many. + + Enumeration Choices: + + * `FIRST_QUARTILE`: Lowest 25% of days of contributions. + * `FOURTH_QUARTILE`: Highest 25% of days of contributions. More + contributions than the third quartile. + * `NONE`: No contributions occurred. + * `SECOND_QUARTILE`: Second lowest 25% of days of contributions. + More contributions than the first quartile. + * `THIRD_QUARTILE`: Second highest 25% of days of contributions. + More contributions than second quartile, less than the fourth + quartile. + """ + + __schema__ = github_schema + __choices__ = ("FIRST_QUARTILE", "FOURTH_QUARTILE", "NONE", "SECOND_QUARTILE", "THIRD_QUARTILE") + + +Date = sgqlc.types.datetime.Date + +DateTime = sgqlc.types.datetime.DateTime + + +class DefaultRepositoryPermissionField(sgqlc.types.Enum): + """The possible base permissions for repositories. + + Enumeration Choices: + + * `ADMIN`: Can read, write, and administrate repos by default + * `NONE`: No access + * `READ`: Can read repos by default + * `WRITE`: Can read and write repos by default + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "NONE", "READ", "WRITE") + + +class DependencyGraphEcosystem(sgqlc.types.Enum): + """The possible ecosystems of a dependency graph package. + + Enumeration Choices: + + * `ACTIONS`: GitHub Actions + * `COMPOSER`: PHP packages hosted at packagist.org + * `GO`: Go modules + * `MAVEN`: Java artifacts hosted at the Maven central repository + * `NPM`: JavaScript packages hosted at npmjs.com + * `NUGET`: .NET packages hosted at the NuGet Gallery + * `PIP`: Python packages hosted at PyPI.org + * `RUBYGEMS`: Ruby gems hosted at RubyGems.org + * `RUST`: Rust crates + """ + + __schema__ = github_schema + __choices__ = ("ACTIONS", "COMPOSER", "GO", "MAVEN", "NPM", "NUGET", "PIP", "RUBYGEMS", "RUST") + + +class DeploymentOrderField(sgqlc.types.Enum): + """Properties by which deployment connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order collection by creation time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class DeploymentProtectionRuleType(sgqlc.types.Enum): + """The possible protection rule types. + + Enumeration Choices: + + * `REQUIRED_REVIEWERS`: Required reviewers + * `WAIT_TIMER`: Wait timer + """ + + __schema__ = github_schema + __choices__ = ("REQUIRED_REVIEWERS", "WAIT_TIMER") + + +class DeploymentReviewState(sgqlc.types.Enum): + """The possible states for a deployment review. + + Enumeration Choices: + + * `APPROVED`: The deployment was approved. + * `REJECTED`: The deployment was rejected. + """ + + __schema__ = github_schema + __choices__ = ("APPROVED", "REJECTED") + + +class DeploymentState(sgqlc.types.Enum): + """The possible states in which a deployment can be. + + Enumeration Choices: + + * `ABANDONED`: The pending deployment was not updated after 30 + minutes. + * `ACTIVE`: The deployment is currently active. + * `DESTROYED`: An inactive transient deployment. + * `ERROR`: The deployment experienced an error. + * `FAILURE`: The deployment has failed. + * `INACTIVE`: The deployment is inactive. + * `IN_PROGRESS`: The deployment is in progress. + * `PENDING`: The deployment is pending. + * `QUEUED`: The deployment has queued + * `WAITING`: The deployment is waiting. + """ + + __schema__ = github_schema + __choices__ = ("ABANDONED", "ACTIVE", "DESTROYED", "ERROR", "FAILURE", "INACTIVE", "IN_PROGRESS", "PENDING", "QUEUED", "WAITING") + + +class DeploymentStatusState(sgqlc.types.Enum): + """The possible states for a deployment status. + + Enumeration Choices: + + * `ERROR`: The deployment experienced an error. + * `FAILURE`: The deployment has failed. + * `INACTIVE`: The deployment is inactive. + * `IN_PROGRESS`: The deployment is in progress. + * `PENDING`: The deployment is pending. + * `QUEUED`: The deployment is queued + * `SUCCESS`: The deployment was successful. + * `WAITING`: The deployment is waiting. + """ + + __schema__ = github_schema + __choices__ = ("ERROR", "FAILURE", "INACTIVE", "IN_PROGRESS", "PENDING", "QUEUED", "SUCCESS", "WAITING") + + +class DiffSide(sgqlc.types.Enum): + """The possible sides of a diff. + + Enumeration Choices: + + * `LEFT`: The left side of the diff. + * `RIGHT`: The right side of the diff. + """ + + __schema__ = github_schema + __choices__ = ("LEFT", "RIGHT") + + +class DiscussionOrderField(sgqlc.types.Enum): + """Properties by which discussion connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order discussions by creation time. + * `UPDATED_AT`: Order discussions by most recent modification + time. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "UPDATED_AT") + + +class DiscussionPollOptionOrderField(sgqlc.types.Enum): + """Properties by which discussion poll option connections can be + ordered. + + Enumeration Choices: + + * `AUTHORED_ORDER`: Order poll options by the order that the poll + author specified when creating the poll. + * `VOTE_COUNT`: Order poll options by the number of votes it has. + """ + + __schema__ = github_schema + __choices__ = ("AUTHORED_ORDER", "VOTE_COUNT") + + +class DismissReason(sgqlc.types.Enum): + """The possible reasons that a Dependabot alert was dismissed. + + Enumeration Choices: + + * `FIX_STARTED`: A fix has already been started + * `INACCURATE`: This alert is inaccurate or incorrect + * `NOT_USED`: Vulnerable code is not actually used + * `NO_BANDWIDTH`: No bandwidth to fix this + * `TOLERABLE_RISK`: Risk is tolerable to this project + """ + + __schema__ = github_schema + __choices__ = ("FIX_STARTED", "INACCURATE", "NOT_USED", "NO_BANDWIDTH", "TOLERABLE_RISK") + + +class EnterpriseAdministratorInvitationOrderField(sgqlc.types.Enum): + """Properties by which enterprise administrator invitation + connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order enterprise administrator member invitations + by creation time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class EnterpriseAdministratorRole(sgqlc.types.Enum): + """The possible administrator roles in an enterprise account. + + Enumeration Choices: + + * `BILLING_MANAGER`: Represents a billing manager of the + enterprise account. + * `OWNER`: Represents an owner of the enterprise account. + """ + + __schema__ = github_schema + __choices__ = ("BILLING_MANAGER", "OWNER") + + +class EnterpriseDefaultRepositoryPermissionSettingValue(sgqlc.types.Enum): + """The possible values for the enterprise base repository permission + setting. + + Enumeration Choices: + + * `ADMIN`: Organization members will be able to clone, pull, push, + and add new collaborators to all organization repositories. + * `NONE`: Organization members will only be able to clone and pull + public repositories. + * `NO_POLICY`: Organizations in the enterprise choose base + repository permissions for their members. + * `READ`: Organization members will be able to clone and pull all + organization repositories. + * `WRITE`: Organization members will be able to clone, pull, and + push all organization repositories. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "NONE", "NO_POLICY", "READ", "WRITE") + + +class EnterpriseEnabledDisabledSettingValue(sgqlc.types.Enum): + """The possible values for an enabled/disabled enterprise setting. + + Enumeration Choices: + + * `DISABLED`: The setting is disabled for organizations in the + enterprise. + * `ENABLED`: The setting is enabled for organizations in the + enterprise. + * `NO_POLICY`: There is no policy set for organizations in the + enterprise. + """ + + __schema__ = github_schema + __choices__ = ("DISABLED", "ENABLED", "NO_POLICY") + + +class EnterpriseEnabledSettingValue(sgqlc.types.Enum): + """The possible values for an enabled/no policy enterprise setting. + + Enumeration Choices: + + * `ENABLED`: The setting is enabled for organizations in the + enterprise. + * `NO_POLICY`: There is no policy set for organizations in the + enterprise. + """ + + __schema__ = github_schema + __choices__ = ("ENABLED", "NO_POLICY") + + +class EnterpriseMemberOrderField(sgqlc.types.Enum): + """Properties by which enterprise member connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order enterprise members by creation time + * `LOGIN`: Order enterprise members by login + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "LOGIN") + + +class EnterpriseMembersCanCreateRepositoriesSettingValue(sgqlc.types.Enum): + """The possible values for the enterprise members can create + repositories setting. + + Enumeration Choices: + + * `ALL`: Members will be able to create public and private + repositories. + * `DISABLED`: Members will not be able to create public or private + repositories. + * `NO_POLICY`: Organization administrators choose whether to allow + members to create repositories. + * `PRIVATE`: Members will be able to create only private + repositories. + * `PUBLIC`: Members will be able to create only public + repositories. + """ + + __schema__ = github_schema + __choices__ = ("ALL", "DISABLED", "NO_POLICY", "PRIVATE", "PUBLIC") + + +class EnterpriseMembersCanMakePurchasesSettingValue(sgqlc.types.Enum): + """The possible values for the members can make purchases setting. + + Enumeration Choices: + + * `DISABLED`: The setting is disabled for organizations in the + enterprise. + * `ENABLED`: The setting is enabled for organizations in the + enterprise. + """ + + __schema__ = github_schema + __choices__ = ("DISABLED", "ENABLED") + + +class EnterpriseServerInstallationOrderField(sgqlc.types.Enum): + """Properties by which Enterprise Server installation connections can + be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order Enterprise Server installations by creation + time + * `CUSTOMER_NAME`: Order Enterprise Server installations by + customer name + * `HOST_NAME`: Order Enterprise Server installations by host name + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "CUSTOMER_NAME", "HOST_NAME") + + +class EnterpriseServerUserAccountEmailOrderField(sgqlc.types.Enum): + """Properties by which Enterprise Server user account email + connections can be ordered. + + Enumeration Choices: + + * `EMAIL`: Order emails by email + """ + + __schema__ = github_schema + __choices__ = ("EMAIL",) + + +class EnterpriseServerUserAccountOrderField(sgqlc.types.Enum): + """Properties by which Enterprise Server user account connections can + be ordered. + + Enumeration Choices: + + * `LOGIN`: Order user accounts by login + * `REMOTE_CREATED_AT`: Order user accounts by creation time on the + Enterprise Server installation + """ + + __schema__ = github_schema + __choices__ = ("LOGIN", "REMOTE_CREATED_AT") + + +class EnterpriseServerUserAccountsUploadOrderField(sgqlc.types.Enum): + """Properties by which Enterprise Server user accounts upload + connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order user accounts uploads by creation time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class EnterpriseServerUserAccountsUploadSyncState(sgqlc.types.Enum): + """Synchronization state of the Enterprise Server user accounts + upload + + Enumeration Choices: + + * `FAILURE`: The synchronization of the upload failed. + * `PENDING`: The synchronization of the upload is pending. + * `SUCCESS`: The synchronization of the upload succeeded. + """ + + __schema__ = github_schema + __choices__ = ("FAILURE", "PENDING", "SUCCESS") + + +class EnterpriseUserAccountMembershipRole(sgqlc.types.Enum): + """The possible roles for enterprise membership. + + Enumeration Choices: + + * `MEMBER`: The user is a member of an organization in the + enterprise. + * `OWNER`: The user is an owner of an organization in the + enterprise. + """ + + __schema__ = github_schema + __choices__ = ("MEMBER", "OWNER") + + +class EnterpriseUserDeployment(sgqlc.types.Enum): + """The possible GitHub Enterprise deployments where this user can + exist. + + Enumeration Choices: + + * `CLOUD`: The user is part of a GitHub Enterprise Cloud + deployment. + * `SERVER`: The user is part of a GitHub Enterprise Server + deployment. + """ + + __schema__ = github_schema + __choices__ = ("CLOUD", "SERVER") + + +class FileViewedState(sgqlc.types.Enum): + """The possible viewed states of a file . + + Enumeration Choices: + + * `DISMISSED`: The file has new changes since last viewed. + * `UNVIEWED`: The file has not been marked as viewed. + * `VIEWED`: The file has been marked as viewed. + """ + + __schema__ = github_schema + __choices__ = ("DISMISSED", "UNVIEWED", "VIEWED") + + +Float = sgqlc.types.Float + + +class FundingPlatform(sgqlc.types.Enum): + """The possible funding platforms for repository funding links. + + Enumeration Choices: + + * `COMMUNITY_BRIDGE`: Community Bridge funding platform. + * `CUSTOM`: Custom funding platform. + * `GITHUB`: GitHub funding platform. + * `ISSUEHUNT`: IssueHunt funding platform. + * `KO_FI`: Ko-fi funding platform. + * `LFX_CROWDFUNDING`: LFX Crowdfunding funding platform. + * `LIBERAPAY`: Liberapay funding platform. + * `OPEN_COLLECTIVE`: Open Collective funding platform. + * `OTECHIE`: Otechie funding platform. + * `PATREON`: Patreon funding platform. + * `TIDELIFT`: Tidelift funding platform. + """ + + __schema__ = github_schema + __choices__ = ( + "COMMUNITY_BRIDGE", + "CUSTOM", + "GITHUB", + "ISSUEHUNT", + "KO_FI", + "LFX_CROWDFUNDING", + "LIBERAPAY", + "OPEN_COLLECTIVE", + "OTECHIE", + "PATREON", + "TIDELIFT", + ) + + +class GistOrderField(sgqlc.types.Enum): + """Properties by which gist connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order gists by creation time + * `PUSHED_AT`: Order gists by push time + * `UPDATED_AT`: Order gists by update time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "PUSHED_AT", "UPDATED_AT") + + +class GistPrivacy(sgqlc.types.Enum): + """The privacy of a Gist + + Enumeration Choices: + + * `ALL`: Gists that are public and secret + * `PUBLIC`: Public + * `SECRET`: Secret + """ + + __schema__ = github_schema + __choices__ = ("ALL", "PUBLIC", "SECRET") + + +class GitObjectID(sgqlc.types.Scalar): + """A Git object ID.""" + + __schema__ = github_schema + + +class GitSSHRemote(sgqlc.types.Scalar): + """Git SSH string""" + + __schema__ = github_schema + + +class GitSignatureState(sgqlc.types.Enum): + """The state of a Git signature. + + Enumeration Choices: + + * `BAD_CERT`: The signing certificate or its chain could not be + verified + * `BAD_EMAIL`: Invalid email used for signing + * `EXPIRED_KEY`: Signing key expired + * `GPGVERIFY_ERROR`: Internal error - the GPG verification service + misbehaved + * `GPGVERIFY_UNAVAILABLE`: Internal error - the GPG verification + service is unavailable at the moment + * `INVALID`: Invalid signature + * `MALFORMED_SIG`: Malformed signature + * `NOT_SIGNING_KEY`: The usage flags for the key that signed this + don't allow signing + * `NO_USER`: Email used for signing not known to GitHub + * `OCSP_ERROR`: Valid signature, though certificate revocation + check failed + * `OCSP_PENDING`: Valid signature, pending certificate revocation + checking + * `OCSP_REVOKED`: One or more certificates in chain has been + revoked + * `UNKNOWN_KEY`: Key used for signing not known to GitHub + * `UNKNOWN_SIG_TYPE`: Unknown signature type + * `UNSIGNED`: Unsigned + * `UNVERIFIED_EMAIL`: Email used for signing unverified on GitHub + * `VALID`: Valid signature and verified by GitHub + """ + + __schema__ = github_schema + __choices__ = ( + "BAD_CERT", + "BAD_EMAIL", + "EXPIRED_KEY", + "GPGVERIFY_ERROR", + "GPGVERIFY_UNAVAILABLE", + "INVALID", + "MALFORMED_SIG", + "NOT_SIGNING_KEY", + "NO_USER", + "OCSP_ERROR", + "OCSP_PENDING", + "OCSP_REVOKED", + "UNKNOWN_KEY", + "UNKNOWN_SIG_TYPE", + "UNSIGNED", + "UNVERIFIED_EMAIL", + "VALID", + ) + + +class GitTimestamp(sgqlc.types.Scalar): + """An ISO-8601 encoded date string. Unlike the DateTime type, + GitTimestamp is not converted in UTC. + """ + + __schema__ = github_schema + + +class HTML(sgqlc.types.Scalar): + """A string containing HTML code.""" + + __schema__ = github_schema + + +ID = sgqlc.types.ID + + +class IdentityProviderConfigurationState(sgqlc.types.Enum): + """The possible states in which authentication can be configured with + an identity provider. + + Enumeration Choices: + + * `CONFIGURED`: Authentication with an identity provider is + configured but not enforced. + * `ENFORCED`: Authentication with an identity provider is + configured and enforced. + * `UNCONFIGURED`: Authentication with an identity provider is not + configured. + """ + + __schema__ = github_schema + __choices__ = ("CONFIGURED", "ENFORCED", "UNCONFIGURED") + + +Int = sgqlc.types.Int + + +class IpAllowListEnabledSettingValue(sgqlc.types.Enum): + """The possible values for the IP allow list enabled setting. + + Enumeration Choices: + + * `DISABLED`: The setting is disabled for the owner. + * `ENABLED`: The setting is enabled for the owner. + """ + + __schema__ = github_schema + __choices__ = ("DISABLED", "ENABLED") + + +class IpAllowListEntryOrderField(sgqlc.types.Enum): + """Properties by which IP allow list entry connections can be + ordered. + + Enumeration Choices: + + * `ALLOW_LIST_VALUE`: Order IP allow list entries by the allow + list value. + * `CREATED_AT`: Order IP allow list entries by creation time. + """ + + __schema__ = github_schema + __choices__ = ("ALLOW_LIST_VALUE", "CREATED_AT") + + +class IpAllowListForInstalledAppsEnabledSettingValue(sgqlc.types.Enum): + """The possible values for the IP allow list configuration for + installed GitHub Apps setting. + + Enumeration Choices: + + * `DISABLED`: The setting is disabled for the owner. + * `ENABLED`: The setting is enabled for the owner. + """ + + __schema__ = github_schema + __choices__ = ("DISABLED", "ENABLED") + + +class IssueClosedStateReason(sgqlc.types.Enum): + """The possible state reasons of a closed issue. + + Enumeration Choices: + + * `COMPLETED`: An issue that has been closed as completed + * `NOT_PLANNED`: An issue that has been closed as not planned + """ + + __schema__ = github_schema + __choices__ = ("COMPLETED", "NOT_PLANNED") + + +class IssueCommentOrderField(sgqlc.types.Enum): + """Properties by which issue comment connections can be ordered. + + Enumeration Choices: + + * `UPDATED_AT`: Order issue comments by update time + """ + + __schema__ = github_schema + __choices__ = ("UPDATED_AT",) + + +class IssueOrderField(sgqlc.types.Enum): + """Properties by which issue connections can be ordered. + + Enumeration Choices: + + * `COMMENTS`: Order issues by comment count + * `CREATED_AT`: Order issues by creation time + * `UPDATED_AT`: Order issues by update time + """ + + __schema__ = github_schema + __choices__ = ("COMMENTS", "CREATED_AT", "UPDATED_AT") + + +class IssueState(sgqlc.types.Enum): + """The possible states of an issue. + + Enumeration Choices: + + * `CLOSED`: An issue that has been closed + * `OPEN`: An issue that is still open + """ + + __schema__ = github_schema + __choices__ = ("CLOSED", "OPEN") + + +class IssueStateReason(sgqlc.types.Enum): + """The possible state reasons of an issue. + + Enumeration Choices: + + * `COMPLETED`: An issue that has been closed as completed + * `NOT_PLANNED`: An issue that has been closed as not planned + * `REOPENED`: An issue that has been reopened + """ + + __schema__ = github_schema + __choices__ = ("COMPLETED", "NOT_PLANNED", "REOPENED") + + +class IssueTimelineItemsItemType(sgqlc.types.Enum): + """The possible item types found in a timeline. + + Enumeration Choices: + + * `ADDED_TO_PROJECT_EVENT`: Represents a 'added_to_project' event + on a given issue or pull request. + * `ASSIGNED_EVENT`: Represents an 'assigned' event on any + assignable object. + * `CLOSED_EVENT`: Represents a 'closed' event on any `Closable`. + * `COMMENT_DELETED_EVENT`: Represents a 'comment_deleted' event on + a given issue or pull request. + * `CONNECTED_EVENT`: Represents a 'connected' event on a given + issue or pull request. + * `CONVERTED_NOTE_TO_ISSUE_EVENT`: Represents a + 'converted_note_to_issue' event on a given issue or pull + request. + * `CONVERTED_TO_DISCUSSION_EVENT`: Represents a + 'converted_to_discussion' event on a given issue. + * `CROSS_REFERENCED_EVENT`: Represents a mention made by one issue + or pull request to another. + * `DEMILESTONED_EVENT`: Represents a 'demilestoned' event on a + given issue or pull request. + * `DISCONNECTED_EVENT`: Represents a 'disconnected' event on a + given issue or pull request. + * `ISSUE_COMMENT`: Represents a comment on an Issue. + * `LABELED_EVENT`: Represents a 'labeled' event on a given issue + or pull request. + * `LOCKED_EVENT`: Represents a 'locked' event on a given issue or + pull request. + * `MARKED_AS_DUPLICATE_EVENT`: Represents a 'marked_as_duplicate' + event on a given issue or pull request. + * `MENTIONED_EVENT`: Represents a 'mentioned' event on a given + issue or pull request. + * `MILESTONED_EVENT`: Represents a 'milestoned' event on a given + issue or pull request. + * `MOVED_COLUMNS_IN_PROJECT_EVENT`: Represents a + 'moved_columns_in_project' event on a given issue or pull + request. + * `PINNED_EVENT`: Represents a 'pinned' event on a given issue or + pull request. + * `REFERENCED_EVENT`: Represents a 'referenced' event on a given + `ReferencedSubject`. + * `REMOVED_FROM_PROJECT_EVENT`: Represents a + 'removed_from_project' event on a given issue or pull request. + * `RENAMED_TITLE_EVENT`: Represents a 'renamed' event on a given + issue or pull request + * `REOPENED_EVENT`: Represents a 'reopened' event on any + `Closable`. + * `SUBSCRIBED_EVENT`: Represents a 'subscribed' event on a given + `Subscribable`. + * `TRANSFERRED_EVENT`: Represents a 'transferred' event on a given + issue or pull request. + * `UNASSIGNED_EVENT`: Represents an 'unassigned' event on any + assignable object. + * `UNLABELED_EVENT`: Represents an 'unlabeled' event on a given + issue or pull request. + * `UNLOCKED_EVENT`: Represents an 'unlocked' event on a given + issue or pull request. + * `UNMARKED_AS_DUPLICATE_EVENT`: Represents an + 'unmarked_as_duplicate' event on a given issue or pull request. + * `UNPINNED_EVENT`: Represents an 'unpinned' event on a given + issue or pull request. + * `UNSUBSCRIBED_EVENT`: Represents an 'unsubscribed' event on a + given `Subscribable`. + * `USER_BLOCKED_EVENT`: Represents a 'user_blocked' event on a + given user. + """ + + __schema__ = github_schema + __choices__ = ( + "ADDED_TO_PROJECT_EVENT", + "ASSIGNED_EVENT", + "CLOSED_EVENT", + "COMMENT_DELETED_EVENT", + "CONNECTED_EVENT", + "CONVERTED_NOTE_TO_ISSUE_EVENT", + "CONVERTED_TO_DISCUSSION_EVENT", + "CROSS_REFERENCED_EVENT", + "DEMILESTONED_EVENT", + "DISCONNECTED_EVENT", + "ISSUE_COMMENT", + "LABELED_EVENT", + "LOCKED_EVENT", + "MARKED_AS_DUPLICATE_EVENT", + "MENTIONED_EVENT", + "MILESTONED_EVENT", + "MOVED_COLUMNS_IN_PROJECT_EVENT", + "PINNED_EVENT", + "REFERENCED_EVENT", + "REMOVED_FROM_PROJECT_EVENT", + "RENAMED_TITLE_EVENT", + "REOPENED_EVENT", + "SUBSCRIBED_EVENT", + "TRANSFERRED_EVENT", + "UNASSIGNED_EVENT", + "UNLABELED_EVENT", + "UNLOCKED_EVENT", + "UNMARKED_AS_DUPLICATE_EVENT", + "UNPINNED_EVENT", + "UNSUBSCRIBED_EVENT", + "USER_BLOCKED_EVENT", + ) + + +class LabelOrderField(sgqlc.types.Enum): + """Properties by which label connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order labels by creation time + * `NAME`: Order labels by name + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "NAME") + + +class LanguageOrderField(sgqlc.types.Enum): + """Properties by which language connections can be ordered. + + Enumeration Choices: + + * `SIZE`: Order languages by the size of all files containing the + language + """ + + __schema__ = github_schema + __choices__ = ("SIZE",) + + +class LockReason(sgqlc.types.Enum): + """The possible reasons that an issue or pull request was locked. + + Enumeration Choices: + + * `OFF_TOPIC`: The issue or pull request was locked because the + conversation was off-topic. + * `RESOLVED`: The issue or pull request was locked because the + conversation was resolved. + * `SPAM`: The issue or pull request was locked because the + conversation was spam. + * `TOO_HEATED`: The issue or pull request was locked because the + conversation was too heated. + """ + + __schema__ = github_schema + __choices__ = ("OFF_TOPIC", "RESOLVED", "SPAM", "TOO_HEATED") + + +class MergeStateStatus(sgqlc.types.Enum): + """Detailed status information about a pull request merge. + + Enumeration Choices: + + * `BEHIND`: The head ref is out of date. + * `BLOCKED`: The merge is blocked. + * `CLEAN`: Mergeable and passing commit status. + * `DIRTY`: The merge commit cannot be cleanly created. + * `HAS_HOOKS`: Mergeable with passing commit status and pre- + receive hooks. + * `UNKNOWN`: The state cannot currently be determined. + * `UNSTABLE`: Mergeable with non-passing commit status. + """ + + __schema__ = github_schema + __choices__ = ("BEHIND", "BLOCKED", "CLEAN", "DIRTY", "HAS_HOOKS", "UNKNOWN", "UNSTABLE") + + +class MergeableState(sgqlc.types.Enum): + """Whether or not a PullRequest can be merged. + + Enumeration Choices: + + * `CONFLICTING`: The pull request cannot be merged due to merge + conflicts. + * `MERGEABLE`: The pull request can be merged. + * `UNKNOWN`: The mergeability of the pull request is still being + calculated. + """ + + __schema__ = github_schema + __choices__ = ("CONFLICTING", "MERGEABLE", "UNKNOWN") + + +class MigrationSourceType(sgqlc.types.Enum): + """Represents the different Octoshift migration sources. + + Enumeration Choices: + + * `AZURE_DEVOPS`: An Azure DevOps migration source. + * `BITBUCKET_SERVER`: A Bitbucket Server migration source. + * `GITHUB`: A GitHub migration source. + * `GITHUB_ARCHIVE`: A GitHub Migration API source. + * `GITLAB`: A GitLab migration source. + """ + + __schema__ = github_schema + __choices__ = ("AZURE_DEVOPS", "BITBUCKET_SERVER", "GITHUB", "GITHUB_ARCHIVE", "GITLAB") + + +class MigrationState(sgqlc.types.Enum): + """The Octoshift migration state. + + Enumeration Choices: + + * `FAILED`: The Octoshift migration has failed. + * `FAILED_VALIDATION`: The Octoshift migration has invalid + credentials. + * `IN_PROGRESS`: The Octoshift migration is in progress. + * `NOT_STARTED`: The Octoshift migration has not started. + * `PENDING_VALIDATION`: The Octoshift migration needs to have its + credentials validated. + * `QUEUED`: The Octoshift migration has been queued. + * `SUCCEEDED`: The Octoshift migration has succeeded. + """ + + __schema__ = github_schema + __choices__ = ("FAILED", "FAILED_VALIDATION", "IN_PROGRESS", "NOT_STARTED", "PENDING_VALIDATION", "QUEUED", "SUCCEEDED") + + +class MilestoneOrderField(sgqlc.types.Enum): + """Properties by which milestone connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order milestones by when they were created. + * `DUE_DATE`: Order milestones by when they are due. + * `NUMBER`: Order milestones by their number. + * `UPDATED_AT`: Order milestones by when they were last updated. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "DUE_DATE", "NUMBER", "UPDATED_AT") + + +class MilestoneState(sgqlc.types.Enum): + """The possible states of a milestone. + + Enumeration Choices: + + * `CLOSED`: A milestone that has been closed. + * `OPEN`: A milestone that is still open. + """ + + __schema__ = github_schema + __choices__ = ("CLOSED", "OPEN") + + +class NotificationRestrictionSettingValue(sgqlc.types.Enum): + """The possible values for the notification restriction setting. + + Enumeration Choices: + + * `DISABLED`: The setting is disabled for the owner. + * `ENABLED`: The setting is enabled for the owner. + """ + + __schema__ = github_schema + __choices__ = ("DISABLED", "ENABLED") + + +class OIDCProviderType(sgqlc.types.Enum): + """The OIDC identity provider type + + Enumeration Choices: + + * `AAD`: Azure Active Directory + """ + + __schema__ = github_schema + __choices__ = ("AAD",) + + +class OauthApplicationCreateAuditEntryState(sgqlc.types.Enum): + """The state of an OAuth Application when it was created. + + Enumeration Choices: + + * `ACTIVE`: The OAuth Application was active and allowed to have + OAuth Accesses. + * `PENDING_DELETION`: The OAuth Application was in the process of + being deleted. + * `SUSPENDED`: The OAuth Application was suspended from generating + OAuth Accesses due to abuse or security concerns. + """ + + __schema__ = github_schema + __choices__ = ("ACTIVE", "PENDING_DELETION", "SUSPENDED") + + +class OperationType(sgqlc.types.Enum): + """The corresponding operation type for the action + + Enumeration Choices: + + * `ACCESS`: An existing resource was accessed + * `AUTHENTICATION`: A resource performed an authentication event + * `CREATE`: A new resource was created + * `MODIFY`: An existing resource was modified + * `REMOVE`: An existing resource was removed + * `RESTORE`: An existing resource was restored + * `TRANSFER`: An existing resource was transferred between + multiple resources + """ + + __schema__ = github_schema + __choices__ = ("ACCESS", "AUTHENTICATION", "CREATE", "MODIFY", "REMOVE", "RESTORE", "TRANSFER") + + +class OrderDirection(sgqlc.types.Enum): + """Possible directions in which to order a list of items when + provided an `orderBy` argument. + + Enumeration Choices: + + * `ASC`: Specifies an ascending order for a given `orderBy` + argument. + * `DESC`: Specifies a descending order for a given `orderBy` + argument. + """ + + __schema__ = github_schema + __choices__ = ("ASC", "DESC") + + +class OrgAddMemberAuditEntryPermission(sgqlc.types.Enum): + """The permissions available to members on an Organization. + + Enumeration Choices: + + * `ADMIN`: Can read, clone, push, and add collaborators to + repositories. + * `READ`: Can read and clone repositories. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "READ") + + +class OrgCreateAuditEntryBillingPlan(sgqlc.types.Enum): + """The billing plans available for organizations. + + Enumeration Choices: + + * `BUSINESS`: Team Plan + * `BUSINESS_PLUS`: Enterprise Cloud Plan + * `FREE`: Free Plan + * `TIERED_PER_SEAT`: Tiered Per Seat Plan + * `UNLIMITED`: Legacy Unlimited Plan + """ + + __schema__ = github_schema + __choices__ = ("BUSINESS", "BUSINESS_PLUS", "FREE", "TIERED_PER_SEAT", "UNLIMITED") + + +class OrgEnterpriseOwnerOrderField(sgqlc.types.Enum): + """Properties by which enterprise owners can be ordered. + + Enumeration Choices: + + * `LOGIN`: Order enterprise owners by login. + """ + + __schema__ = github_schema + __choices__ = ("LOGIN",) + + +class OrgRemoveBillingManagerAuditEntryReason(sgqlc.types.Enum): + """The reason a billing manager was removed from an Organization. + + Enumeration Choices: + + * `SAML_EXTERNAL_IDENTITY_MISSING`: SAML external identity missing + * `SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY`: SAML SSO + enforcement requires an external identity + * `TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE`: The organization + required 2FA of its billing managers and this user did not have + 2FA enabled. + """ + + __schema__ = github_schema + __choices__ = ( + "SAML_EXTERNAL_IDENTITY_MISSING", + "SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY", + "TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE", + ) + + +class OrgRemoveMemberAuditEntryMembershipType(sgqlc.types.Enum): + """The type of membership a user has with an Organization. + + Enumeration Choices: + + * `ADMIN`: Organization administrators have full access and can + change several settings, including the names of repositories + that belong to the Organization and Owners team membership. In + addition, organization admins can delete the organization and + all of its repositories. + * `BILLING_MANAGER`: A billing manager is a user who manages the + billing settings for the Organization, such as updating payment + information. + * `DIRECT_MEMBER`: A direct member is a user that is a member of + the Organization. + * `OUTSIDE_COLLABORATOR`: An outside collaborator is a person who + isn't explicitly a member of the Organization, but who has Read, + Write, or Admin permissions to one or more repositories in the + organization. + * `SUSPENDED`: A suspended member. + * `UNAFFILIATED`: An unaffiliated collaborator is a person who is + not a member of the Organization and does not have access to any + repositories in the Organization. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "BILLING_MANAGER", "DIRECT_MEMBER", "OUTSIDE_COLLABORATOR", "SUSPENDED", "UNAFFILIATED") + + +class OrgRemoveMemberAuditEntryReason(sgqlc.types.Enum): + """The reason a member was removed from an Organization. + + Enumeration Choices: + + * `SAML_EXTERNAL_IDENTITY_MISSING`: SAML external identity missing + * `SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY`: SAML SSO + enforcement requires an external identity + * `TWO_FACTOR_ACCOUNT_RECOVERY`: User was removed from + organization during account recovery + * `TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE`: The organization + required 2FA of its billing managers and this user did not have + 2FA enabled. + * `USER_ACCOUNT_DELETED`: User account has been deleted + """ + + __schema__ = github_schema + __choices__ = ( + "SAML_EXTERNAL_IDENTITY_MISSING", + "SAML_SSO_ENFORCEMENT_REQUIRES_EXTERNAL_IDENTITY", + "TWO_FACTOR_ACCOUNT_RECOVERY", + "TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE", + "USER_ACCOUNT_DELETED", + ) + + +class OrgRemoveOutsideCollaboratorAuditEntryMembershipType(sgqlc.types.Enum): + """The type of membership a user has with an Organization. + + Enumeration Choices: + + * `BILLING_MANAGER`: A billing manager is a user who manages the + billing settings for the Organization, such as updating payment + information. + * `OUTSIDE_COLLABORATOR`: An outside collaborator is a person who + isn't explicitly a member of the Organization, but who has Read, + Write, or Admin permissions to one or more repositories in the + organization. + * `UNAFFILIATED`: An unaffiliated collaborator is a person who is + not a member of the Organization and does not have access to any + repositories in the organization. + """ + + __schema__ = github_schema + __choices__ = ("BILLING_MANAGER", "OUTSIDE_COLLABORATOR", "UNAFFILIATED") + + +class OrgRemoveOutsideCollaboratorAuditEntryReason(sgqlc.types.Enum): + """The reason an outside collaborator was removed from an + Organization. + + Enumeration Choices: + + * `SAML_EXTERNAL_IDENTITY_MISSING`: SAML external identity missing + * `TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE`: The organization + required 2FA of its billing managers and this user did not have + 2FA enabled. + """ + + __schema__ = github_schema + __choices__ = ("SAML_EXTERNAL_IDENTITY_MISSING", "TWO_FACTOR_REQUIREMENT_NON_COMPLIANCE") + + +class OrgUpdateDefaultRepositoryPermissionAuditEntryPermission(sgqlc.types.Enum): + """The default permission a repository can have in an Organization. + + Enumeration Choices: + + * `ADMIN`: Can read, clone, push, and add collaborators to + repositories. + * `NONE`: No default permission value. + * `READ`: Can read and clone repositories. + * `WRITE`: Can read, clone and push to repositories. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "NONE", "READ", "WRITE") + + +class OrgUpdateMemberAuditEntryPermission(sgqlc.types.Enum): + """The permissions available to members on an Organization. + + Enumeration Choices: + + * `ADMIN`: Can read, clone, push, and add collaborators to + repositories. + * `READ`: Can read and clone repositories. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "READ") + + +class OrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility(sgqlc.types.Enum): + """The permissions available for repository creation on an + Organization. + + Enumeration Choices: + + * `ALL`: All organization members are restricted from creating any + repositories. + * `INTERNAL`: All organization members are restricted from + creating internal repositories. + * `NONE`: All organization members are allowed to create any + repositories. + * `PRIVATE`: All organization members are restricted from creating + private repositories. + * `PRIVATE_INTERNAL`: All organization members are restricted from + creating private or internal repositories. + * `PUBLIC`: All organization members are restricted from creating + public repositories. + * `PUBLIC_INTERNAL`: All organization members are restricted from + creating public or internal repositories. + * `PUBLIC_PRIVATE`: All organization members are restricted from + creating public or private repositories. + """ + + __schema__ = github_schema + __choices__ = ("ALL", "INTERNAL", "NONE", "PRIVATE", "PRIVATE_INTERNAL", "PUBLIC", "PUBLIC_INTERNAL", "PUBLIC_PRIVATE") + + +class OrganizationInvitationRole(sgqlc.types.Enum): + """The possible organization invitation roles. + + Enumeration Choices: + + * `ADMIN`: The user is invited to be an admin of the organization. + * `BILLING_MANAGER`: The user is invited to be a billing manager + of the organization. + * `DIRECT_MEMBER`: The user is invited to be a direct member of + the organization. + * `REINSTATE`: The user's previous role will be reinstated. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "BILLING_MANAGER", "DIRECT_MEMBER", "REINSTATE") + + +class OrganizationInvitationType(sgqlc.types.Enum): + """The possible organization invitation types. + + Enumeration Choices: + + * `EMAIL`: The invitation was to an email address. + * `USER`: The invitation was to an existing user. + """ + + __schema__ = github_schema + __choices__ = ("EMAIL", "USER") + + +class OrganizationMemberRole(sgqlc.types.Enum): + """The possible roles within an organization for its members. + + Enumeration Choices: + + * `ADMIN`: The user is an administrator of the organization. + * `MEMBER`: The user is a member of the organization. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "MEMBER") + + +class OrganizationMembersCanCreateRepositoriesSettingValue(sgqlc.types.Enum): + """The possible values for the members can create repositories + setting on an organization. + + Enumeration Choices: + + * `ALL`: Members will be able to create public and private + repositories. + * `DISABLED`: Members will not be able to create public or private + repositories. + * `INTERNAL`: Members will be able to create only internal + repositories. + * `PRIVATE`: Members will be able to create only private + repositories. + """ + + __schema__ = github_schema + __choices__ = ("ALL", "DISABLED", "INTERNAL", "PRIVATE") + + +class OrganizationOrderField(sgqlc.types.Enum): + """Properties by which organization connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order organizations by creation time + * `LOGIN`: Order organizations by login + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "LOGIN") + + +class PackageFileOrderField(sgqlc.types.Enum): + """Properties by which package file connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order package files by creation time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class PackageOrderField(sgqlc.types.Enum): + """Properties by which package connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order packages by creation time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class PackageType(sgqlc.types.Enum): + """The possible types of a package. + + Enumeration Choices: + + * `DEBIAN`: A debian package. + * `MAVEN`: A maven package. + * `NPM`: An npm package. + * `NUGET`: A nuget package. + * `PYPI`: A python package. + * `RUBYGEMS`: A rubygems package. + """ + + __schema__ = github_schema + __choices__ = ("DEBIAN", "MAVEN", "NPM", "NUGET", "PYPI", "RUBYGEMS") + + +class PackageVersionOrderField(sgqlc.types.Enum): + """Properties by which package version connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order package versions by creation time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class PatchStatus(sgqlc.types.Enum): + """The possible types of patch statuses. + + Enumeration Choices: + + * `ADDED`: The file was added. Git status 'A'. + * `CHANGED`: The file's type was changed. Git status 'T'. + * `COPIED`: The file was copied. Git status 'C'. + * `DELETED`: The file was deleted. Git status 'D'. + * `MODIFIED`: The file's contents were changed. Git status 'M'. + * `RENAMED`: The file was renamed. Git status 'R'. + """ + + __schema__ = github_schema + __choices__ = ("ADDED", "CHANGED", "COPIED", "DELETED", "MODIFIED", "RENAMED") + + +class PinnableItemType(sgqlc.types.Enum): + """Represents items that can be pinned to a profile page or + dashboard. + + Enumeration Choices: + + * `GIST`: A gist. + * `ISSUE`: An issue. + * `ORGANIZATION`: An organization. + * `PROJECT`: A project. + * `PULL_REQUEST`: A pull request. + * `REPOSITORY`: A repository. + * `TEAM`: A team. + * `USER`: A user. + """ + + __schema__ = github_schema + __choices__ = ("GIST", "ISSUE", "ORGANIZATION", "PROJECT", "PULL_REQUEST", "REPOSITORY", "TEAM", "USER") + + +class PinnedDiscussionGradient(sgqlc.types.Enum): + """Preconfigured gradients that may be used to style discussions + pinned within a repository. + + Enumeration Choices: + + * `BLUE_MINT`: A gradient of blue to mint + * `BLUE_PURPLE`: A gradient of blue to purple + * `PINK_BLUE`: A gradient of pink to blue + * `PURPLE_CORAL`: A gradient of purple to coral + * `RED_ORANGE`: A gradient of red to orange + """ + + __schema__ = github_schema + __choices__ = ("BLUE_MINT", "BLUE_PURPLE", "PINK_BLUE", "PURPLE_CORAL", "RED_ORANGE") + + +class PinnedDiscussionPattern(sgqlc.types.Enum): + """Preconfigured background patterns that may be used to style + discussions pinned within a repository. + + Enumeration Choices: + + * `CHEVRON_UP`: An upward-facing chevron pattern + * `DOT`: A hollow dot pattern + * `DOT_FILL`: A solid dot pattern + * `HEART_FILL`: A heart pattern + * `PLUS`: A plus sign pattern + * `ZAP`: A lightning bolt pattern + """ + + __schema__ = github_schema + __choices__ = ("CHEVRON_UP", "DOT", "DOT_FILL", "HEART_FILL", "PLUS", "ZAP") + + +class PreciseDateTime(sgqlc.types.Scalar): + """An ISO-8601 encoded UTC date string with millisecond precision.""" + + __schema__ = github_schema + + +class ProjectCardArchivedState(sgqlc.types.Enum): + """The possible archived states of a project card. + + Enumeration Choices: + + * `ARCHIVED`: A project card that is archived + * `NOT_ARCHIVED`: A project card that is not archived + """ + + __schema__ = github_schema + __choices__ = ("ARCHIVED", "NOT_ARCHIVED") + + +class ProjectCardState(sgqlc.types.Enum): + """Various content states of a ProjectCard + + Enumeration Choices: + + * `CONTENT_ONLY`: The card has content only. + * `NOTE_ONLY`: The card has a note only. + * `REDACTED`: The card is redacted. + """ + + __schema__ = github_schema + __choices__ = ("CONTENT_ONLY", "NOTE_ONLY", "REDACTED") + + +class ProjectColumnPurpose(sgqlc.types.Enum): + """The semantic purpose of the column - todo, in progress, or done. + + Enumeration Choices: + + * `DONE`: The column contains cards which are complete + * `IN_PROGRESS`: The column contains cards which are currently + being worked on + * `TODO`: The column contains cards still to be worked on + """ + + __schema__ = github_schema + __choices__ = ("DONE", "IN_PROGRESS", "TODO") + + +class ProjectItemType(sgqlc.types.Enum): + """The type of a project item. + + Enumeration Choices: + + * `DRAFT_ISSUE`: Draft Issue + * `ISSUE`: Issue + * `PULL_REQUEST`: Pull Request + * `REDACTED`: Redacted Item + """ + + __schema__ = github_schema + __choices__ = ("DRAFT_ISSUE", "ISSUE", "PULL_REQUEST", "REDACTED") + + +class ProjectNextFieldType(sgqlc.types.Enum): + """The type of a project next field. + + Enumeration Choices: + + * `ASSIGNEES`: Assignees + * `DATE`: Date + * `ITERATION`: Iteration + * `LABELS`: Labels + * `LINKED_PULL_REQUESTS`: Linked Pull Requests + * `MILESTONE`: Milestone + * `NUMBER`: Number + * `REPOSITORY`: Repository + * `REVIEWERS`: Reviewers + * `SINGLE_SELECT`: Single Select + * `TEXT`: Text + * `TITLE`: Title + * `TRACKS`: Tracks + """ + + __schema__ = github_schema + __choices__ = ( + "ASSIGNEES", + "DATE", + "ITERATION", + "LABELS", + "LINKED_PULL_REQUESTS", + "MILESTONE", + "NUMBER", + "REPOSITORY", + "REVIEWERS", + "SINGLE_SELECT", + "TEXT", + "TITLE", + "TRACKS", + ) + + +class ProjectNextOrderField(sgqlc.types.Enum): + """Properties by which the return project can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: The project's date and time of creation + * `NUMBER`: The project's number + * `TITLE`: The project's title + * `UPDATED_AT`: The project's date and time of update + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "NUMBER", "TITLE", "UPDATED_AT") + + +class ProjectOrderField(sgqlc.types.Enum): + """Properties by which project connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order projects by creation time + * `NAME`: Order projects by name + * `UPDATED_AT`: Order projects by update time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "NAME", "UPDATED_AT") + + +class ProjectState(sgqlc.types.Enum): + """State of the project; either 'open' or 'closed' + + Enumeration Choices: + + * `CLOSED`: The project is closed. + * `OPEN`: The project is open. + """ + + __schema__ = github_schema + __choices__ = ("CLOSED", "OPEN") + + +class ProjectTemplate(sgqlc.types.Enum): + """GitHub-provided templates for Projects + + Enumeration Choices: + + * `AUTOMATED_KANBAN_V2`: Create a board with v2 triggers to + automatically move cards across To do, In progress and Done + columns. + * `AUTOMATED_REVIEWS_KANBAN`: Create a board with triggers to + automatically move cards across columns with review automation. + * `BASIC_KANBAN`: Create a board with columns for To do, In + progress and Done. + * `BUG_TRIAGE`: Create a board to triage and prioritize bugs with + To do, priority, and Done columns. + """ + + __schema__ = github_schema + __choices__ = ("AUTOMATED_KANBAN_V2", "AUTOMATED_REVIEWS_KANBAN", "BASIC_KANBAN", "BUG_TRIAGE") + + +class ProjectViewLayout(sgqlc.types.Enum): + """The layout of a project view. + + Enumeration Choices: + + * `BOARD_LAYOUT`: Board layout + * `TABLE_LAYOUT`: Table layout + """ + + __schema__ = github_schema + __choices__ = ("BOARD_LAYOUT", "TABLE_LAYOUT") + + +class PullRequestMergeMethod(sgqlc.types.Enum): + """Represents available types of methods to use when merging a pull + request. + + Enumeration Choices: + + * `MERGE`: Add all commits from the head branch to the base branch + with a merge commit. + * `REBASE`: Add all commits from the head branch onto the base + branch individually. + * `SQUASH`: Combine all commits from the head branch into a single + commit in the base branch. + """ + + __schema__ = github_schema + __choices__ = ("MERGE", "REBASE", "SQUASH") + + +class PullRequestOrderField(sgqlc.types.Enum): + """Properties by which pull_requests connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order pull_requests by creation time + * `UPDATED_AT`: Order pull_requests by update time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "UPDATED_AT") + + +class PullRequestReviewCommentState(sgqlc.types.Enum): + """The possible states of a pull request review comment. + + Enumeration Choices: + + * `PENDING`: A comment that is part of a pending review + * `SUBMITTED`: A comment that is part of a submitted review + """ + + __schema__ = github_schema + __choices__ = ("PENDING", "SUBMITTED") + + +class PullRequestReviewDecision(sgqlc.types.Enum): + """The review status of a pull request. + + Enumeration Choices: + + * `APPROVED`: The pull request has received an approving review. + * `CHANGES_REQUESTED`: Changes have been requested on the pull + request. + * `REVIEW_REQUIRED`: A review is required before the pull request + can be merged. + """ + + __schema__ = github_schema + __choices__ = ("APPROVED", "CHANGES_REQUESTED", "REVIEW_REQUIRED") + + +class PullRequestReviewEvent(sgqlc.types.Enum): + """The possible events to perform on a pull request review. + + Enumeration Choices: + + * `APPROVE`: Submit feedback and approve merging these changes. + * `COMMENT`: Submit general feedback without explicit approval. + * `DISMISS`: Dismiss review so it now longer effects merging. + * `REQUEST_CHANGES`: Submit feedback that must be addressed before + merging. + """ + + __schema__ = github_schema + __choices__ = ("APPROVE", "COMMENT", "DISMISS", "REQUEST_CHANGES") + + +class PullRequestReviewState(sgqlc.types.Enum): + """The possible states of a pull request review. + + Enumeration Choices: + + * `APPROVED`: A review allowing the pull request to merge. + * `CHANGES_REQUESTED`: A review blocking the pull request from + merging. + * `COMMENTED`: An informational review. + * `DISMISSED`: A review that has been dismissed. + * `PENDING`: A review that has not yet been submitted. + """ + + __schema__ = github_schema + __choices__ = ("APPROVED", "CHANGES_REQUESTED", "COMMENTED", "DISMISSED", "PENDING") + + +class PullRequestState(sgqlc.types.Enum): + """The possible states of a pull request. + + Enumeration Choices: + + * `CLOSED`: A pull request that has been closed without being + merged. + * `MERGED`: A pull request that has been closed by being merged. + * `OPEN`: A pull request that is still open. + """ + + __schema__ = github_schema + __choices__ = ("CLOSED", "MERGED", "OPEN") + + +class PullRequestTimelineItemsItemType(sgqlc.types.Enum): + """The possible item types found in a timeline. + + Enumeration Choices: + + * `ADDED_TO_MERGE_QUEUE_EVENT`: Represents an + 'added_to_merge_queue' event on a given pull request. + * `ADDED_TO_PROJECT_EVENT`: Represents a 'added_to_project' event + on a given issue or pull request. + * `ASSIGNED_EVENT`: Represents an 'assigned' event on any + assignable object. + * `AUTOMATIC_BASE_CHANGE_FAILED_EVENT`: Represents a + 'automatic_base_change_failed' event on a given pull request. + * `AUTOMATIC_BASE_CHANGE_SUCCEEDED_EVENT`: Represents a + 'automatic_base_change_succeeded' event on a given pull request. + * `AUTO_MERGE_DISABLED_EVENT`: Represents a 'auto_merge_disabled' + event on a given pull request. + * `AUTO_MERGE_ENABLED_EVENT`: Represents a 'auto_merge_enabled' + event on a given pull request. + * `AUTO_REBASE_ENABLED_EVENT`: Represents a 'auto_rebase_enabled' + event on a given pull request. + * `AUTO_SQUASH_ENABLED_EVENT`: Represents a 'auto_squash_enabled' + event on a given pull request. + * `BASE_REF_CHANGED_EVENT`: Represents a 'base_ref_changed' event + on a given issue or pull request. + * `BASE_REF_DELETED_EVENT`: Represents a 'base_ref_deleted' event + on a given pull request. + * `BASE_REF_FORCE_PUSHED_EVENT`: Represents a + 'base_ref_force_pushed' event on a given pull request. + * `CLOSED_EVENT`: Represents a 'closed' event on any `Closable`. + * `COMMENT_DELETED_EVENT`: Represents a 'comment_deleted' event on + a given issue or pull request. + * `CONNECTED_EVENT`: Represents a 'connected' event on a given + issue or pull request. + * `CONVERTED_NOTE_TO_ISSUE_EVENT`: Represents a + 'converted_note_to_issue' event on a given issue or pull + request. + * `CONVERTED_TO_DISCUSSION_EVENT`: Represents a + 'converted_to_discussion' event on a given issue. + * `CONVERT_TO_DRAFT_EVENT`: Represents a 'convert_to_draft' event + on a given pull request. + * `CROSS_REFERENCED_EVENT`: Represents a mention made by one issue + or pull request to another. + * `DEMILESTONED_EVENT`: Represents a 'demilestoned' event on a + given issue or pull request. + * `DEPLOYED_EVENT`: Represents a 'deployed' event on a given pull + request. + * `DEPLOYMENT_ENVIRONMENT_CHANGED_EVENT`: Represents a + 'deployment_environment_changed' event on a given pull request. + * `DISCONNECTED_EVENT`: Represents a 'disconnected' event on a + given issue or pull request. + * `HEAD_REF_DELETED_EVENT`: Represents a 'head_ref_deleted' event + on a given pull request. + * `HEAD_REF_FORCE_PUSHED_EVENT`: Represents a + 'head_ref_force_pushed' event on a given pull request. + * `HEAD_REF_RESTORED_EVENT`: Represents a 'head_ref_restored' + event on a given pull request. + * `ISSUE_COMMENT`: Represents a comment on an Issue. + * `LABELED_EVENT`: Represents a 'labeled' event on a given issue + or pull request. + * `LOCKED_EVENT`: Represents a 'locked' event on a given issue or + pull request. + * `MARKED_AS_DUPLICATE_EVENT`: Represents a 'marked_as_duplicate' + event on a given issue or pull request. + * `MENTIONED_EVENT`: Represents a 'mentioned' event on a given + issue or pull request. + * `MERGED_EVENT`: Represents a 'merged' event on a given pull + request. + * `MILESTONED_EVENT`: Represents a 'milestoned' event on a given + issue or pull request. + * `MOVED_COLUMNS_IN_PROJECT_EVENT`: Represents a + 'moved_columns_in_project' event on a given issue or pull + request. + * `PINNED_EVENT`: Represents a 'pinned' event on a given issue or + pull request. + * `PULL_REQUEST_COMMIT`: Represents a Git commit part of a pull + request. + * `PULL_REQUEST_COMMIT_COMMENT_THREAD`: Represents a commit + comment thread part of a pull request. + * `PULL_REQUEST_REVIEW`: A review object for a given pull request. + * `PULL_REQUEST_REVIEW_THREAD`: A threaded list of comments for a + given pull request. + * `PULL_REQUEST_REVISION_MARKER`: Represents the latest point in + the pull request timeline for which the viewer has seen the pull + request's commits. + * `READY_FOR_REVIEW_EVENT`: Represents a 'ready_for_review' event + on a given pull request. + * `REFERENCED_EVENT`: Represents a 'referenced' event on a given + `ReferencedSubject`. + * `REMOVED_FROM_MERGE_QUEUE_EVENT`: Represents a + 'removed_from_merge_queue' event on a given pull request. + * `REMOVED_FROM_PROJECT_EVENT`: Represents a + 'removed_from_project' event on a given issue or pull request. + * `RENAMED_TITLE_EVENT`: Represents a 'renamed' event on a given + issue or pull request + * `REOPENED_EVENT`: Represents a 'reopened' event on any + `Closable`. + * `REVIEW_DISMISSED_EVENT`: Represents a 'review_dismissed' event + on a given issue or pull request. + * `REVIEW_REQUESTED_EVENT`: Represents an 'review_requested' event + on a given pull request. + * `REVIEW_REQUEST_REMOVED_EVENT`: Represents an + 'review_request_removed' event on a given pull request. + * `SUBSCRIBED_EVENT`: Represents a 'subscribed' event on a given + `Subscribable`. + * `TRANSFERRED_EVENT`: Represents a 'transferred' event on a given + issue or pull request. + * `UNASSIGNED_EVENT`: Represents an 'unassigned' event on any + assignable object. + * `UNLABELED_EVENT`: Represents an 'unlabeled' event on a given + issue or pull request. + * `UNLOCKED_EVENT`: Represents an 'unlocked' event on a given + issue or pull request. + * `UNMARKED_AS_DUPLICATE_EVENT`: Represents an + 'unmarked_as_duplicate' event on a given issue or pull request. + * `UNPINNED_EVENT`: Represents an 'unpinned' event on a given + issue or pull request. + * `UNSUBSCRIBED_EVENT`: Represents an 'unsubscribed' event on a + given `Subscribable`. + * `USER_BLOCKED_EVENT`: Represents a 'user_blocked' event on a + given user. + """ + + __schema__ = github_schema + __choices__ = ( + "ADDED_TO_MERGE_QUEUE_EVENT", + "ADDED_TO_PROJECT_EVENT", + "ASSIGNED_EVENT", + "AUTOMATIC_BASE_CHANGE_FAILED_EVENT", + "AUTOMATIC_BASE_CHANGE_SUCCEEDED_EVENT", + "AUTO_MERGE_DISABLED_EVENT", + "AUTO_MERGE_ENABLED_EVENT", + "AUTO_REBASE_ENABLED_EVENT", + "AUTO_SQUASH_ENABLED_EVENT", + "BASE_REF_CHANGED_EVENT", + "BASE_REF_DELETED_EVENT", + "BASE_REF_FORCE_PUSHED_EVENT", + "CLOSED_EVENT", + "COMMENT_DELETED_EVENT", + "CONNECTED_EVENT", + "CONVERTED_NOTE_TO_ISSUE_EVENT", + "CONVERTED_TO_DISCUSSION_EVENT", + "CONVERT_TO_DRAFT_EVENT", + "CROSS_REFERENCED_EVENT", + "DEMILESTONED_EVENT", + "DEPLOYED_EVENT", + "DEPLOYMENT_ENVIRONMENT_CHANGED_EVENT", + "DISCONNECTED_EVENT", + "HEAD_REF_DELETED_EVENT", + "HEAD_REF_FORCE_PUSHED_EVENT", + "HEAD_REF_RESTORED_EVENT", + "ISSUE_COMMENT", + "LABELED_EVENT", + "LOCKED_EVENT", + "MARKED_AS_DUPLICATE_EVENT", + "MENTIONED_EVENT", + "MERGED_EVENT", + "MILESTONED_EVENT", + "MOVED_COLUMNS_IN_PROJECT_EVENT", + "PINNED_EVENT", + "PULL_REQUEST_COMMIT", + "PULL_REQUEST_COMMIT_COMMENT_THREAD", + "PULL_REQUEST_REVIEW", + "PULL_REQUEST_REVIEW_THREAD", + "PULL_REQUEST_REVISION_MARKER", + "READY_FOR_REVIEW_EVENT", + "REFERENCED_EVENT", + "REMOVED_FROM_MERGE_QUEUE_EVENT", + "REMOVED_FROM_PROJECT_EVENT", + "RENAMED_TITLE_EVENT", + "REOPENED_EVENT", + "REVIEW_DISMISSED_EVENT", + "REVIEW_REQUESTED_EVENT", + "REVIEW_REQUEST_REMOVED_EVENT", + "SUBSCRIBED_EVENT", + "TRANSFERRED_EVENT", + "UNASSIGNED_EVENT", + "UNLABELED_EVENT", + "UNLOCKED_EVENT", + "UNMARKED_AS_DUPLICATE_EVENT", + "UNPINNED_EVENT", + "UNSUBSCRIBED_EVENT", + "USER_BLOCKED_EVENT", + ) + + +class PullRequestUpdateState(sgqlc.types.Enum): + """The possible target states when updating a pull request. + + Enumeration Choices: + + * `CLOSED`: A pull request that has been closed without being + merged. + * `OPEN`: A pull request that is still open. + """ + + __schema__ = github_schema + __choices__ = ("CLOSED", "OPEN") + + +class ReactionContent(sgqlc.types.Enum): + """Emojis that can be attached to Issues, Pull Requests and Comments. + + Enumeration Choices: + + * `CONFUSED`: Represents the `:confused:` emoji. + * `EYES`: Represents the `:eyes:` emoji. + * `HEART`: Represents the `:heart:` emoji. + * `HOORAY`: Represents the `:hooray:` emoji. + * `LAUGH`: Represents the `:laugh:` emoji. + * `ROCKET`: Represents the `:rocket:` emoji. + * `THUMBS_DOWN`: Represents the `:-1:` emoji. + * `THUMBS_UP`: Represents the `:+1:` emoji. + """ + + __schema__ = github_schema + __choices__ = ("CONFUSED", "EYES", "HEART", "HOORAY", "LAUGH", "ROCKET", "THUMBS_DOWN", "THUMBS_UP") + + +class ReactionOrderField(sgqlc.types.Enum): + """A list of fields that reactions can be ordered by. + + Enumeration Choices: + + * `CREATED_AT`: Allows ordering a list of reactions by when they + were created. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class RefOrderField(sgqlc.types.Enum): + """Properties by which ref connections can be ordered. + + Enumeration Choices: + + * `ALPHABETICAL`: Order refs by their alphanumeric name + * `TAG_COMMIT_DATE`: Order refs by underlying commit date if the + ref prefix is refs/tags/ + """ + + __schema__ = github_schema + __choices__ = ("ALPHABETICAL", "TAG_COMMIT_DATE") + + +class ReleaseOrderField(sgqlc.types.Enum): + """Properties by which release connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order releases by creation time + * `NAME`: Order releases alphabetically by name + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "NAME") + + +class RepoAccessAuditEntryVisibility(sgqlc.types.Enum): + """The privacy of a repository + + Enumeration Choices: + + * `INTERNAL`: The repository is visible only to users in the same + business. + * `PRIVATE`: The repository is visible only to those with explicit + access. + * `PUBLIC`: The repository is visible to everyone. + """ + + __schema__ = github_schema + __choices__ = ("INTERNAL", "PRIVATE", "PUBLIC") + + +class RepoAddMemberAuditEntryVisibility(sgqlc.types.Enum): + """The privacy of a repository + + Enumeration Choices: + + * `INTERNAL`: The repository is visible only to users in the same + business. + * `PRIVATE`: The repository is visible only to those with explicit + access. + * `PUBLIC`: The repository is visible to everyone. + """ + + __schema__ = github_schema + __choices__ = ("INTERNAL", "PRIVATE", "PUBLIC") + + +class RepoArchivedAuditEntryVisibility(sgqlc.types.Enum): + """The privacy of a repository + + Enumeration Choices: + + * `INTERNAL`: The repository is visible only to users in the same + business. + * `PRIVATE`: The repository is visible only to those with explicit + access. + * `PUBLIC`: The repository is visible to everyone. + """ + + __schema__ = github_schema + __choices__ = ("INTERNAL", "PRIVATE", "PUBLIC") + + +class RepoChangeMergeSettingAuditEntryMergeType(sgqlc.types.Enum): + """The merge options available for pull requests to this repository. + + Enumeration Choices: + + * `MERGE`: The pull request is added to the base branch in a merge + commit. + * `REBASE`: Commits from the pull request are added onto the base + branch individually without a merge commit. + * `SQUASH`: The pull request's commits are squashed into a single + commit before they are merged to the base branch. + """ + + __schema__ = github_schema + __choices__ = ("MERGE", "REBASE", "SQUASH") + + +class RepoCreateAuditEntryVisibility(sgqlc.types.Enum): + """The privacy of a repository + + Enumeration Choices: + + * `INTERNAL`: The repository is visible only to users in the same + business. + * `PRIVATE`: The repository is visible only to those with explicit + access. + * `PUBLIC`: The repository is visible to everyone. + """ + + __schema__ = github_schema + __choices__ = ("INTERNAL", "PRIVATE", "PUBLIC") + + +class RepoDestroyAuditEntryVisibility(sgqlc.types.Enum): + """The privacy of a repository + + Enumeration Choices: + + * `INTERNAL`: The repository is visible only to users in the same + business. + * `PRIVATE`: The repository is visible only to those with explicit + access. + * `PUBLIC`: The repository is visible to everyone. + """ + + __schema__ = github_schema + __choices__ = ("INTERNAL", "PRIVATE", "PUBLIC") + + +class RepoRemoveMemberAuditEntryVisibility(sgqlc.types.Enum): + """The privacy of a repository + + Enumeration Choices: + + * `INTERNAL`: The repository is visible only to users in the same + business. + * `PRIVATE`: The repository is visible only to those with explicit + access. + * `PUBLIC`: The repository is visible to everyone. + """ + + __schema__ = github_schema + __choices__ = ("INTERNAL", "PRIVATE", "PUBLIC") + + +class ReportedContentClassifiers(sgqlc.types.Enum): + """The reasons a piece of content can be reported or minimized. + + Enumeration Choices: + + * `ABUSE`: An abusive or harassing piece of content + * `DUPLICATE`: A duplicated piece of content + * `OFF_TOPIC`: An irrelevant piece of content + * `OUTDATED`: An outdated piece of content + * `RESOLVED`: The content has been resolved + * `SPAM`: A spammy piece of content + """ + + __schema__ = github_schema + __choices__ = ("ABUSE", "DUPLICATE", "OFF_TOPIC", "OUTDATED", "RESOLVED", "SPAM") + + +class RepositoryAffiliation(sgqlc.types.Enum): + """The affiliation of a user to a repository + + Enumeration Choices: + + * `COLLABORATOR`: Repositories that the user has been added to as + a collaborator. + * `ORGANIZATION_MEMBER`: Repositories that the user has access to + through being a member of an organization. This includes every + repository on every team that the user is on. + * `OWNER`: Repositories that are owned by the authenticated user. + """ + + __schema__ = github_schema + __choices__ = ("COLLABORATOR", "ORGANIZATION_MEMBER", "OWNER") + + +class RepositoryContributionType(sgqlc.types.Enum): + """The reason a repository is listed as 'contributed'. + + Enumeration Choices: + + * `COMMIT`: Created a commit + * `ISSUE`: Created an issue + * `PULL_REQUEST`: Created a pull request + * `PULL_REQUEST_REVIEW`: Reviewed a pull request + * `REPOSITORY`: Created the repository + """ + + __schema__ = github_schema + __choices__ = ("COMMIT", "ISSUE", "PULL_REQUEST", "PULL_REQUEST_REVIEW", "REPOSITORY") + + +class RepositoryInteractionLimit(sgqlc.types.Enum): + """A repository interaction limit. + + Enumeration Choices: + + * `COLLABORATORS_ONLY`: Users that are not collaborators will not + be able to interact with the repository. + * `CONTRIBUTORS_ONLY`: Users that have not previously committed to + a repository’s default branch will be unable to interact with + the repository. + * `EXISTING_USERS`: Users that have recently created their account + will be unable to interact with the repository. + * `NO_LIMIT`: No interaction limits are enabled. + """ + + __schema__ = github_schema + __choices__ = ("COLLABORATORS_ONLY", "CONTRIBUTORS_ONLY", "EXISTING_USERS", "NO_LIMIT") + + +class RepositoryInteractionLimitExpiry(sgqlc.types.Enum): + """The length for a repository interaction limit to be enabled for. + + Enumeration Choices: + + * `ONE_DAY`: The interaction limit will expire after 1 day. + * `ONE_MONTH`: The interaction limit will expire after 1 month. + * `ONE_WEEK`: The interaction limit will expire after 1 week. + * `SIX_MONTHS`: The interaction limit will expire after 6 months. + * `THREE_DAYS`: The interaction limit will expire after 3 days. + """ + + __schema__ = github_schema + __choices__ = ("ONE_DAY", "ONE_MONTH", "ONE_WEEK", "SIX_MONTHS", "THREE_DAYS") + + +class RepositoryInteractionLimitOrigin(sgqlc.types.Enum): + """Indicates where an interaction limit is configured. + + Enumeration Choices: + + * `ORGANIZATION`: A limit that is configured at the organization + level. + * `REPOSITORY`: A limit that is configured at the repository + level. + * `USER`: A limit that is configured at the user-wide level. + """ + + __schema__ = github_schema + __choices__ = ("ORGANIZATION", "REPOSITORY", "USER") + + +class RepositoryInvitationOrderField(sgqlc.types.Enum): + """Properties by which repository invitation connections can be + ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order repository invitations by creation time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class RepositoryLockReason(sgqlc.types.Enum): + """The possible reasons a given repository could be in a locked + state. + + Enumeration Choices: + + * `BILLING`: The repository is locked due to a billing related + reason. + * `MIGRATING`: The repository is locked due to a migration. + * `MOVING`: The repository is locked due to a move. + * `RENAME`: The repository is locked due to a rename. + """ + + __schema__ = github_schema + __choices__ = ("BILLING", "MIGRATING", "MOVING", "RENAME") + + +class RepositoryMigrationOrderDirection(sgqlc.types.Enum): + """Possible directions in which to order a list of repository + migrations when provided an `orderBy` argument. + + Enumeration Choices: + + * `ASC`: Specifies an ascending order for a given `orderBy` + argument. + * `DESC`: Specifies a descending order for a given `orderBy` + argument. + """ + + __schema__ = github_schema + __choices__ = ("ASC", "DESC") + + +class RepositoryMigrationOrderField(sgqlc.types.Enum): + """Properties by which repository migrations can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order mannequins why when they were created. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class RepositoryOrderField(sgqlc.types.Enum): + """Properties by which repository connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order repositories by creation time + * `NAME`: Order repositories by name + * `PUSHED_AT`: Order repositories by push time + * `STARGAZERS`: Order repositories by number of stargazers + * `UPDATED_AT`: Order repositories by update time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "NAME", "PUSHED_AT", "STARGAZERS", "UPDATED_AT") + + +class RepositoryPermission(sgqlc.types.Enum): + """The access level to a repository + + Enumeration Choices: + + * `ADMIN`: Can read, clone, and push to this repository. Can also + manage issues, pull requests, and repository settings, including + adding collaborators + * `MAINTAIN`: Can read, clone, and push to this repository. They + can also manage issues, pull requests, and some repository + settings + * `READ`: Can read and clone this repository. Can also open and + comment on issues and pull requests + * `TRIAGE`: Can read and clone this repository. Can also manage + issues and pull requests + * `WRITE`: Can read, clone, and push to this repository. Can also + manage issues and pull requests + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "MAINTAIN", "READ", "TRIAGE", "WRITE") + + +class RepositoryPrivacy(sgqlc.types.Enum): + """The privacy of a repository + + Enumeration Choices: + + * `PRIVATE`: Private + * `PUBLIC`: Public + """ + + __schema__ = github_schema + __choices__ = ("PRIVATE", "PUBLIC") + + +class RepositoryVisibility(sgqlc.types.Enum): + """The repository's visibility level. + + Enumeration Choices: + + * `INTERNAL`: The repository is visible only to users in the same + business. + * `PRIVATE`: The repository is visible only to those with explicit + access. + * `PUBLIC`: The repository is visible to everyone. + """ + + __schema__ = github_schema + __choices__ = ("INTERNAL", "PRIVATE", "PUBLIC") + + +class RepositoryVulnerabilityAlertState(sgqlc.types.Enum): + """The possible states of an alert + + Enumeration Choices: + + * `DISMISSED`: An alert that has been manually closed by a user. + * `FIXED`: An alert that has been resolved by a code change. + * `OPEN`: An alert that is still open. + """ + + __schema__ = github_schema + __choices__ = ("DISMISSED", "FIXED", "OPEN") + + +class RequestableCheckStatusState(sgqlc.types.Enum): + """The possible states that can be requested when creating a check + run. + + Enumeration Choices: + + * `COMPLETED`: The check suite or run has been completed. + * `IN_PROGRESS`: The check suite or run is in progress. + * `PENDING`: The check suite or run is in pending state. + * `QUEUED`: The check suite or run has been queued. + * `WAITING`: The check suite or run is in waiting state. + """ + + __schema__ = github_schema + __choices__ = ("COMPLETED", "IN_PROGRESS", "PENDING", "QUEUED", "WAITING") + + +class RoleInOrganization(sgqlc.types.Enum): + """Possible roles a user may have in relation to an organization. + + Enumeration Choices: + + * `DIRECT_MEMBER`: A user who is a direct member of the + organization. + * `OWNER`: A user with full administrative access to the + organization. + * `UNAFFILIATED`: A user who is unaffiliated with the + organization. + """ + + __schema__ = github_schema + __choices__ = ("DIRECT_MEMBER", "OWNER", "UNAFFILIATED") + + +class SamlDigestAlgorithm(sgqlc.types.Enum): + """The possible digest algorithms used to sign SAML requests for an + identity provider. + + Enumeration Choices: + + * `SHA1`: SHA1 + * `SHA256`: SHA256 + * `SHA384`: SHA384 + * `SHA512`: SHA512 + """ + + __schema__ = github_schema + __choices__ = ("SHA1", "SHA256", "SHA384", "SHA512") + + +class SamlSignatureAlgorithm(sgqlc.types.Enum): + """The possible signature algorithms used to sign SAML requests for a + Identity Provider. + + Enumeration Choices: + + * `RSA_SHA1`: RSA-SHA1 + * `RSA_SHA256`: RSA-SHA256 + * `RSA_SHA384`: RSA-SHA384 + * `RSA_SHA512`: RSA-SHA512 + """ + + __schema__ = github_schema + __choices__ = ("RSA_SHA1", "RSA_SHA256", "RSA_SHA384", "RSA_SHA512") + + +class SavedReplyOrderField(sgqlc.types.Enum): + """Properties by which saved reply connections can be ordered. + + Enumeration Choices: + + * `UPDATED_AT`: Order saved reply by when they were updated. + """ + + __schema__ = github_schema + __choices__ = ("UPDATED_AT",) + + +class SearchType(sgqlc.types.Enum): + """Represents the individual results of a search. + + Enumeration Choices: + + * `DISCUSSION`: Returns matching discussions in repositories. + * `ISSUE`: Returns results matching issues in repositories. + * `REPOSITORY`: Returns results matching repositories. + * `USER`: Returns results matching users and organizations on + GitHub. + """ + + __schema__ = github_schema + __choices__ = ("DISCUSSION", "ISSUE", "REPOSITORY", "USER") + + +class SecurityAdvisoryClassification(sgqlc.types.Enum): + """Classification of the advisory. + + Enumeration Choices: + + * `GENERAL`: Classification of general advisories. + * `MALWARE`: Classification of malware advisories. + """ + + __schema__ = github_schema + __choices__ = ("GENERAL", "MALWARE") + + +class SecurityAdvisoryEcosystem(sgqlc.types.Enum): + """The possible ecosystems of a security vulnerability's package. + + Enumeration Choices: + + * `COMPOSER`: PHP packages hosted at packagist.org + * `GO`: Go modules + * `MAVEN`: Java artifacts hosted at the Maven central repository + * `NPM`: JavaScript packages hosted at npmjs.com + * `NUGET`: .NET packages hosted at the NuGet Gallery + * `PIP`: Python packages hosted at PyPI.org + * `RUBYGEMS`: Ruby gems hosted at RubyGems.org + * `RUST`: Rust crates + """ + + __schema__ = github_schema + __choices__ = ("COMPOSER", "GO", "MAVEN", "NPM", "NUGET", "PIP", "RUBYGEMS", "RUST") + + +class SecurityAdvisoryIdentifierType(sgqlc.types.Enum): + """Identifier formats available for advisories. + + Enumeration Choices: + + * `CVE`: Common Vulnerabilities and Exposures Identifier. + * `GHSA`: GitHub Security Advisory ID. + """ + + __schema__ = github_schema + __choices__ = ("CVE", "GHSA") + + +class SecurityAdvisoryOrderField(sgqlc.types.Enum): + """Properties by which security advisory connections can be ordered. + + Enumeration Choices: + + * `PUBLISHED_AT`: Order advisories by publication time + * `UPDATED_AT`: Order advisories by update time + """ + + __schema__ = github_schema + __choices__ = ("PUBLISHED_AT", "UPDATED_AT") + + +class SecurityAdvisorySeverity(sgqlc.types.Enum): + """Severity of the vulnerability. + + Enumeration Choices: + + * `CRITICAL`: Critical. + * `HIGH`: High. + * `LOW`: Low. + * `MODERATE`: Moderate. + """ + + __schema__ = github_schema + __choices__ = ("CRITICAL", "HIGH", "LOW", "MODERATE") + + +class SecurityVulnerabilityOrderField(sgqlc.types.Enum): + """Properties by which security vulnerability connections can be + ordered. + + Enumeration Choices: + + * `UPDATED_AT`: Order vulnerability by update time + """ + + __schema__ = github_schema + __choices__ = ("UPDATED_AT",) + + +class SponsorOrderField(sgqlc.types.Enum): + """Properties by which sponsor connections can be ordered. + + Enumeration Choices: + + * `LOGIN`: Order sponsorable entities by login (username). + * `RELEVANCE`: Order sponsors by their relevance to the viewer. + """ + + __schema__ = github_schema + __choices__ = ("LOGIN", "RELEVANCE") + + +class SponsorableOrderField(sgqlc.types.Enum): + """Properties by which sponsorable connections can be ordered. + + Enumeration Choices: + + * `LOGIN`: Order sponsorable entities by login (username). + """ + + __schema__ = github_schema + __choices__ = ("LOGIN",) + + +class SponsorsActivityAction(sgqlc.types.Enum): + """The possible actions that GitHub Sponsors activities can + represent. + + Enumeration Choices: + + * `CANCELLED_SPONSORSHIP`: The activity was cancelling a + sponsorship. + * `NEW_SPONSORSHIP`: The activity was starting a sponsorship. + * `PENDING_CHANGE`: The activity was scheduling a downgrade or + cancellation. + * `REFUND`: The activity was funds being refunded to the sponsor + or GitHub. + * `SPONSOR_MATCH_DISABLED`: The activity was disabling matching + for a previously matched sponsorship. + * `TIER_CHANGE`: The activity was changing the sponsorship tier, + either directly by the sponsor or by a scheduled/pending change. + """ + + __schema__ = github_schema + __choices__ = ("CANCELLED_SPONSORSHIP", "NEW_SPONSORSHIP", "PENDING_CHANGE", "REFUND", "SPONSOR_MATCH_DISABLED", "TIER_CHANGE") + + +class SponsorsActivityOrderField(sgqlc.types.Enum): + """Properties by which GitHub Sponsors activity connections can be + ordered. + + Enumeration Choices: + + * `TIMESTAMP`: Order activities by when they happened. + """ + + __schema__ = github_schema + __choices__ = ("TIMESTAMP",) + + +class SponsorsActivityPeriod(sgqlc.types.Enum): + """The possible time periods for which Sponsors activities can be + requested. + + Enumeration Choices: + + * `ALL`: Don't restrict the activity to any date range, include + all activity. + * `DAY`: The previous calendar day. + * `MONTH`: The previous thirty days. + * `WEEK`: The previous seven days. + """ + + __schema__ = github_schema + __choices__ = ("ALL", "DAY", "MONTH", "WEEK") + + +class SponsorsGoalKind(sgqlc.types.Enum): + """The different kinds of goals a GitHub Sponsors member can have. + + Enumeration Choices: + + * `MONTHLY_SPONSORSHIP_AMOUNT`: The goal is about getting a + certain amount in USD from sponsorships each month. + * `TOTAL_SPONSORS_COUNT`: The goal is about reaching a certain + number of sponsors. + """ + + __schema__ = github_schema + __choices__ = ("MONTHLY_SPONSORSHIP_AMOUNT", "TOTAL_SPONSORS_COUNT") + + +class SponsorsTierOrderField(sgqlc.types.Enum): + """Properties by which Sponsors tiers connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order tiers by creation time. + * `MONTHLY_PRICE_IN_CENTS`: Order tiers by their monthly price in + cents + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "MONTHLY_PRICE_IN_CENTS") + + +class SponsorshipNewsletterOrderField(sgqlc.types.Enum): + """Properties by which sponsorship update connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order sponsorship newsletters by when they were + created. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class SponsorshipOrderField(sgqlc.types.Enum): + """Properties by which sponsorship connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order sponsorship by creation time. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class SponsorshipPrivacy(sgqlc.types.Enum): + """The privacy of a sponsorship + + Enumeration Choices: + + * `PRIVATE`: Private + * `PUBLIC`: Public + """ + + __schema__ = github_schema + __choices__ = ("PRIVATE", "PUBLIC") + + +class StarOrderField(sgqlc.types.Enum): + """Properties by which star connections can be ordered. + + Enumeration Choices: + + * `STARRED_AT`: Allows ordering a list of stars by when they were + created. + """ + + __schema__ = github_schema + __choices__ = ("STARRED_AT",) + + +class StatusState(sgqlc.types.Enum): + """The possible commit status states. + + Enumeration Choices: + + * `ERROR`: Status is errored. + * `EXPECTED`: Status is expected. + * `FAILURE`: Status is failing. + * `PENDING`: Status is pending. + * `SUCCESS`: Status is successful. + """ + + __schema__ = github_schema + __choices__ = ("ERROR", "EXPECTED", "FAILURE", "PENDING", "SUCCESS") + + +String = sgqlc.types.String + + +class SubscriptionState(sgqlc.types.Enum): + """The possible states of a subscription. + + Enumeration Choices: + + * `IGNORED`: The User is never notified. + * `SUBSCRIBED`: The User is notified of all conversations. + * `UNSUBSCRIBED`: The User is only notified when participating or + @mentioned. + """ + + __schema__ = github_schema + __choices__ = ("IGNORED", "SUBSCRIBED", "UNSUBSCRIBED") + + +class TeamDiscussionCommentOrderField(sgqlc.types.Enum): + """Properties by which team discussion comment connections can be + ordered. + + Enumeration Choices: + + * `NUMBER`: Allows sequential ordering of team discussion comments + (which is equivalent to chronological ordering). + """ + + __schema__ = github_schema + __choices__ = ("NUMBER",) + + +class TeamDiscussionOrderField(sgqlc.types.Enum): + """Properties by which team discussion connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Allows chronological ordering of team discussions. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT",) + + +class TeamMemberOrderField(sgqlc.types.Enum): + """Properties by which team member connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order team members by creation time + * `LOGIN`: Order team members by login + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "LOGIN") + + +class TeamMemberRole(sgqlc.types.Enum): + """The possible team member roles; either 'maintainer' or 'member'. + + Enumeration Choices: + + * `MAINTAINER`: A team maintainer has permission to add and remove + team members. + * `MEMBER`: A team member has no administrative permissions on the + team. + """ + + __schema__ = github_schema + __choices__ = ("MAINTAINER", "MEMBER") + + +class TeamMembershipType(sgqlc.types.Enum): + """Defines which types of team members are included in the returned + list. Can be one of IMMEDIATE, CHILD_TEAM or ALL. + + Enumeration Choices: + + * `ALL`: Includes immediate and child team members for the team. + * `CHILD_TEAM`: Includes only child team members for the team. + * `IMMEDIATE`: Includes only immediate members of the team. + """ + + __schema__ = github_schema + __choices__ = ("ALL", "CHILD_TEAM", "IMMEDIATE") + + +class TeamOrderField(sgqlc.types.Enum): + """Properties by which team connections can be ordered. + + Enumeration Choices: + + * `NAME`: Allows ordering a list of teams by name. + """ + + __schema__ = github_schema + __choices__ = ("NAME",) + + +class TeamPrivacy(sgqlc.types.Enum): + """The possible team privacy values. + + Enumeration Choices: + + * `SECRET`: A secret team can only be seen by its members. + * `VISIBLE`: A visible team can be seen and @mentioned by every + member of the organization. + """ + + __schema__ = github_schema + __choices__ = ("SECRET", "VISIBLE") + + +class TeamRepositoryOrderField(sgqlc.types.Enum): + """Properties by which team repository connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order repositories by creation time + * `NAME`: Order repositories by name + * `PERMISSION`: Order repositories by permission + * `PUSHED_AT`: Order repositories by push time + * `STARGAZERS`: Order repositories by number of stargazers + * `UPDATED_AT`: Order repositories by update time + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "NAME", "PERMISSION", "PUSHED_AT", "STARGAZERS", "UPDATED_AT") + + +class TeamRole(sgqlc.types.Enum): + """The role of a user on a team. + + Enumeration Choices: + + * `ADMIN`: User has admin rights on the team. + * `MEMBER`: User is a member of the team. + """ + + __schema__ = github_schema + __choices__ = ("ADMIN", "MEMBER") + + +class TopicSuggestionDeclineReason(sgqlc.types.Enum): + """Reason that the suggested topic is declined. + + Enumeration Choices: + + * `NOT_RELEVANT`: The suggested topic is not relevant to the + repository. + * `PERSONAL_PREFERENCE`: The viewer does not like the suggested + topic. + * `TOO_GENERAL`: The suggested topic is too general for the + repository. + * `TOO_SPECIFIC`: The suggested topic is too specific for the + repository (e.g. #ruby-on-rails-version-4-2-1). + """ + + __schema__ = github_schema + __choices__ = ("NOT_RELEVANT", "PERSONAL_PREFERENCE", "TOO_GENERAL", "TOO_SPECIFIC") + + +class TrackedIssueStates(sgqlc.types.Enum): + """The possible states of a tracked issue. + + Enumeration Choices: + + * `CLOSED`: The tracked issue is closed + * `OPEN`: The tracked issue is open + """ + + __schema__ = github_schema + __choices__ = ("CLOSED", "OPEN") + + +class URI(sgqlc.types.Scalar): + """An RFC 3986, RFC 3987, and RFC 6570 (level 4) compliant URI + string. + """ + + __schema__ = github_schema + + +class UserBlockDuration(sgqlc.types.Enum): + """The possible durations that a user can be blocked for. + + Enumeration Choices: + + * `ONE_DAY`: The user was blocked for 1 day + * `ONE_MONTH`: The user was blocked for 30 days + * `ONE_WEEK`: The user was blocked for 7 days + * `PERMANENT`: The user was blocked permanently + * `THREE_DAYS`: The user was blocked for 3 days + """ + + __schema__ = github_schema + __choices__ = ("ONE_DAY", "ONE_MONTH", "ONE_WEEK", "PERMANENT", "THREE_DAYS") + + +class UserStatusOrderField(sgqlc.types.Enum): + """Properties by which user status connections can be ordered. + + Enumeration Choices: + + * `UPDATED_AT`: Order user statuses by when they were updated. + """ + + __schema__ = github_schema + __choices__ = ("UPDATED_AT",) + + +class VerifiableDomainOrderField(sgqlc.types.Enum): + """Properties by which verifiable domain connections can be ordered. + + Enumeration Choices: + + * `CREATED_AT`: Order verifiable domains by their creation date. + * `DOMAIN`: Order verifiable domains by the domain name. + """ + + __schema__ = github_schema + __choices__ = ("CREATED_AT", "DOMAIN") + + +class X509Certificate(sgqlc.types.Scalar): + """A valid x509 certificate string""" + + __schema__ = github_schema + + +######################################################################## +# Input Objects +######################################################################## +class AbortQueuedMigrationsInput(sgqlc.types.Input): + """Autogenerated input type of AbortQueuedMigrations""" + + __schema__ = github_schema + __field_names__ = ("owner_id", "client_mutation_id") + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the organization that is running the migrations.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AcceptEnterpriseAdministratorInvitationInput(sgqlc.types.Input): + """Autogenerated input type of + AcceptEnterpriseAdministratorInvitation + """ + + __schema__ = github_schema + __field_names__ = ("invitation_id", "client_mutation_id") + invitation_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="invitationId") + """The id of the invitation being accepted""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AcceptTopicSuggestionInput(sgqlc.types.Input): + """Autogenerated input type of AcceptTopicSuggestion""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "name", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the suggested topic.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddAssigneesToAssignableInput(sgqlc.types.Input): + """Autogenerated input type of AddAssigneesToAssignable""" + + __schema__ = github_schema + __field_names__ = ("assignable_id", "assignee_ids", "client_mutation_id") + assignable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="assignableId") + """The id of the assignable object to add assignees to.""" + + assignee_ids = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="assigneeIds") + """The id of users to add as assignees.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddCommentInput(sgqlc.types.Input): + """Autogenerated input type of AddComment""" + + __schema__ = github_schema + __field_names__ = ("subject_id", "body", "client_mutation_id") + subject_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subjectId") + """The Node ID of the subject to modify.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The contents of the comment.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddDiscussionCommentInput(sgqlc.types.Input): + """Autogenerated input type of AddDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("discussion_id", "reply_to_id", "body", "client_mutation_id") + discussion_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="discussionId") + """The Node ID of the discussion to comment on.""" + + reply_to_id = sgqlc.types.Field(ID, graphql_name="replyToId") + """The Node ID of the discussion comment within this discussion to + reply to. + """ + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The contents of the comment.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddDiscussionPollVoteInput(sgqlc.types.Input): + """Autogenerated input type of AddDiscussionPollVote""" + + __schema__ = github_schema + __field_names__ = ("poll_option_id", "client_mutation_id") + poll_option_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pollOptionId") + """The Node ID of the discussion poll option to vote for.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddEnterpriseSupportEntitlementInput(sgqlc.types.Input): + """Autogenerated input type of AddEnterpriseSupportEntitlement""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "login", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the Enterprise which the admin belongs to.""" + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of a member who will receive the support entitlement.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddLabelsToLabelableInput(sgqlc.types.Input): + """Autogenerated input type of AddLabelsToLabelable""" + + __schema__ = github_schema + __field_names__ = ("labelable_id", "label_ids", "client_mutation_id") + labelable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="labelableId") + """The id of the labelable object to add labels to.""" + + label_ids = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="labelIds") + """The ids of the labels to add.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddProjectCardInput(sgqlc.types.Input): + """Autogenerated input type of AddProjectCard""" + + __schema__ = github_schema + __field_names__ = ("project_column_id", "content_id", "note", "client_mutation_id") + project_column_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectColumnId") + """The Node ID of the ProjectColumn.""" + + content_id = sgqlc.types.Field(ID, graphql_name="contentId") + """The content of the card. Must be a member of the ProjectCardItem + union + """ + + note = sgqlc.types.Field(String, graphql_name="note") + """The note on the card.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddProjectColumnInput(sgqlc.types.Input): + """Autogenerated input type of AddProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("project_id", "name", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The Node ID of the project.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the column.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddProjectDraftIssueInput(sgqlc.types.Input): + """Autogenerated input type of AddProjectDraftIssue""" + + __schema__ = github_schema + __field_names__ = ("project_id", "title", "body", "assignee_ids", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The ID of the Project to add the draft issue to.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the draft issue.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The body of the draft issue.""" + + assignee_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="assigneeIds") + """The IDs of the assignees of the draft issue.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddProjectNextItemInput(sgqlc.types.Input): + """Autogenerated input type of AddProjectNextItem""" + + __schema__ = github_schema + __field_names__ = ("project_id", "content_id", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The ID of the Project to add the item to.""" + + content_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="contentId") + """The content id of the item (Issue or PullRequest).""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddPullRequestReviewCommentInput(sgqlc.types.Input): + """Autogenerated input type of AddPullRequestReviewComment""" + + __schema__ = github_schema + __field_names__ = ( + "pull_request_id", + "pull_request_review_id", + "commit_oid", + "body", + "path", + "position", + "in_reply_to", + "client_mutation_id", + ) + pull_request_id = sgqlc.types.Field(ID, graphql_name="pullRequestId") + """The node ID of the pull request reviewing""" + + pull_request_review_id = sgqlc.types.Field(ID, graphql_name="pullRequestReviewId") + """The Node ID of the review to modify.""" + + commit_oid = sgqlc.types.Field(GitObjectID, graphql_name="commitOID") + """The SHA of the commit to comment on.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The text of the comment.""" + + path = sgqlc.types.Field(String, graphql_name="path") + """The relative path of the file to comment on.""" + + position = sgqlc.types.Field(Int, graphql_name="position") + """The line index in the diff to comment on.""" + + in_reply_to = sgqlc.types.Field(ID, graphql_name="inReplyTo") + """The comment id to reply to.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddPullRequestReviewInput(sgqlc.types.Input): + """Autogenerated input type of AddPullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "commit_oid", "body", "event", "comments", "threads", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """The Node ID of the pull request to modify.""" + + commit_oid = sgqlc.types.Field(GitObjectID, graphql_name="commitOID") + """The commit OID the review pertains to.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The contents of the review body comment.""" + + event = sgqlc.types.Field(PullRequestReviewEvent, graphql_name="event") + """The event to perform on the pull request review.""" + + comments = sgqlc.types.Field(sgqlc.types.list_of("DraftPullRequestReviewComment"), graphql_name="comments") + """The review line comments.""" + + threads = sgqlc.types.Field(sgqlc.types.list_of("DraftPullRequestReviewThread"), graphql_name="threads") + """The review line comment threads.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddPullRequestReviewThreadInput(sgqlc.types.Input): + """Autogenerated input type of AddPullRequestReviewThread""" + + __schema__ = github_schema + __field_names__ = ( + "path", + "body", + "pull_request_id", + "pull_request_review_id", + "line", + "side", + "start_line", + "start_side", + "client_mutation_id", + ) + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """Path to the file being commented on.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """Body of the thread's first comment.""" + + pull_request_id = sgqlc.types.Field(ID, graphql_name="pullRequestId") + """The node ID of the pull request reviewing""" + + pull_request_review_id = sgqlc.types.Field(ID, graphql_name="pullRequestReviewId") + """The Node ID of the review to modify.""" + + line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="line") + """The line of the blob to which the thread refers. The end of the + line range for multi-line comments. + """ + + side = sgqlc.types.Field(DiffSide, graphql_name="side") + """The side of the diff on which the line resides. For multi-line + comments, this is the side for the end of the line range. + """ + + start_line = sgqlc.types.Field(Int, graphql_name="startLine") + """The first line of the range to which the comment refers.""" + + start_side = sgqlc.types.Field(DiffSide, graphql_name="startSide") + """The side of the diff on which the start line resides.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddReactionInput(sgqlc.types.Input): + """Autogenerated input type of AddReaction""" + + __schema__ = github_schema + __field_names__ = ("subject_id", "content", "client_mutation_id") + subject_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subjectId") + """The Node ID of the subject to modify.""" + + content = sgqlc.types.Field(sgqlc.types.non_null(ReactionContent), graphql_name="content") + """The name of the emoji to react with.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddStarInput(sgqlc.types.Input): + """Autogenerated input type of AddStar""" + + __schema__ = github_schema + __field_names__ = ("starrable_id", "client_mutation_id") + starrable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="starrableId") + """The Starrable ID to star.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddUpvoteInput(sgqlc.types.Input): + """Autogenerated input type of AddUpvote""" + + __schema__ = github_schema + __field_names__ = ("subject_id", "client_mutation_id") + subject_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subjectId") + """The Node ID of the discussion or comment to upvote.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddVerifiableDomainInput(sgqlc.types.Input): + """Autogenerated input type of AddVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("owner_id", "domain", "client_mutation_id") + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the owner to add the domain to""" + + domain = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="domain") + """The URL of the domain""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ApproveDeploymentsInput(sgqlc.types.Input): + """Autogenerated input type of ApproveDeployments""" + + __schema__ = github_schema + __field_names__ = ("workflow_run_id", "environment_ids", "comment", "client_mutation_id") + workflow_run_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="workflowRunId") + """The node ID of the workflow run containing the pending + deployments. + """ + + environment_ids = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="environmentIds") + """The ids of environments to reject deployments""" + + comment = sgqlc.types.Field(String, graphql_name="comment") + """Optional comment for approving deployments""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ApproveVerifiableDomainInput(sgqlc.types.Input): + """Autogenerated input type of ApproveVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the verifiable domain to approve.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ArchiveRepositoryInput(sgqlc.types.Input): + """Autogenerated input type of ArchiveRepository""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The ID of the repository to mark as archived.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AuditLogOrder(sgqlc.types.Input): + """Ordering options for Audit Log connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(AuditLogOrderField, graphql_name="field") + """The field to order Audit Logs by.""" + + direction = sgqlc.types.Field(OrderDirection, graphql_name="direction") + """The ordering direction.""" + + +class CancelEnterpriseAdminInvitationInput(sgqlc.types.Input): + """Autogenerated input type of CancelEnterpriseAdminInvitation""" + + __schema__ = github_schema + __field_names__ = ("invitation_id", "client_mutation_id") + invitation_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="invitationId") + """The Node ID of the pending enterprise administrator invitation.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CancelSponsorshipInput(sgqlc.types.Input): + """Autogenerated input type of CancelSponsorship""" + + __schema__ = github_schema + __field_names__ = ("sponsor_id", "sponsor_login", "sponsorable_id", "sponsorable_login", "client_mutation_id") + sponsor_id = sgqlc.types.Field(ID, graphql_name="sponsorId") + """The ID of the user or organization who is acting as the sponsor, + paying for the sponsorship. Required if sponsorLogin is not given. + """ + + sponsor_login = sgqlc.types.Field(String, graphql_name="sponsorLogin") + """The username of the user or organization who is acting as the + sponsor, paying for the sponsorship. Required if sponsorId is not + given. + """ + + sponsorable_id = sgqlc.types.Field(ID, graphql_name="sponsorableId") + """The ID of the user or organization who is receiving the + sponsorship. Required if sponsorableLogin is not given. + """ + + sponsorable_login = sgqlc.types.Field(String, graphql_name="sponsorableLogin") + """The username of the user or organization who is receiving the + sponsorship. Required if sponsorableId is not given. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ChangeUserStatusInput(sgqlc.types.Input): + """Autogenerated input type of ChangeUserStatus""" + + __schema__ = github_schema + __field_names__ = ("emoji", "message", "organization_id", "limited_availability", "expires_at", "client_mutation_id") + emoji = sgqlc.types.Field(String, graphql_name="emoji") + """The emoji to represent your status. Can either be a native Unicode + emoji or an emoji name with colons, e.g., :grinning:. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A short description of your current status.""" + + organization_id = sgqlc.types.Field(ID, graphql_name="organizationId") + """The ID of the organization whose members will be allowed to see + the status. If omitted, the status will be publicly visible. + """ + + limited_availability = sgqlc.types.Field(Boolean, graphql_name="limitedAvailability") + """Whether this status should indicate you are not fully available on + GitHub, e.g., you are away. + """ + + expires_at = sgqlc.types.Field(DateTime, graphql_name="expiresAt") + """If set, the user status will not be shown after this date.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CheckAnnotationData(sgqlc.types.Input): + """Information from a check run analysis to specific lines of code.""" + + __schema__ = github_schema + __field_names__ = ("path", "location", "annotation_level", "message", "title", "raw_details") + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path of the file to add an annotation to.""" + + location = sgqlc.types.Field(sgqlc.types.non_null("CheckAnnotationRange"), graphql_name="location") + """The location of the annotation""" + + annotation_level = sgqlc.types.Field(sgqlc.types.non_null(CheckAnnotationLevel), graphql_name="annotationLevel") + """Represents an annotation's information level""" + + message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message") + """A short description of the feedback for these lines of code.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The title that represents the annotation.""" + + raw_details = sgqlc.types.Field(String, graphql_name="rawDetails") + """Details about this annotation.""" + + +class CheckAnnotationRange(sgqlc.types.Input): + """Information from a check run analysis to specific lines of code.""" + + __schema__ = github_schema + __field_names__ = ("start_line", "start_column", "end_line", "end_column") + start_line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="startLine") + """The starting line of the range.""" + + start_column = sgqlc.types.Field(Int, graphql_name="startColumn") + """The starting column of the range.""" + + end_line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="endLine") + """The ending line of the range.""" + + end_column = sgqlc.types.Field(Int, graphql_name="endColumn") + """The ending column of the range.""" + + +class CheckRunAction(sgqlc.types.Input): + """Possible further actions the integrator can perform.""" + + __schema__ = github_schema + __field_names__ = ("label", "description", "identifier") + label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label") + """The text to be displayed on a button in the web UI.""" + + description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description") + """A short explanation of what this action would do.""" + + identifier = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="identifier") + """A reference for the action on the integrator's system.""" + + +class CheckRunFilter(sgqlc.types.Input): + """The filters that are available when fetching check runs.""" + + __schema__ = github_schema + __field_names__ = ("check_type", "app_id", "check_name", "status") + check_type = sgqlc.types.Field(CheckRunType, graphql_name="checkType") + """Filters the check runs by this type.""" + + app_id = sgqlc.types.Field(Int, graphql_name="appId") + """Filters the check runs created by this application ID.""" + + check_name = sgqlc.types.Field(String, graphql_name="checkName") + """Filters the check runs by this name.""" + + status = sgqlc.types.Field(CheckStatusState, graphql_name="status") + """Filters the check runs by this status.""" + + +class CheckRunOutput(sgqlc.types.Input): + """Descriptive details about the check run.""" + + __schema__ = github_schema + __field_names__ = ("title", "summary", "text", "annotations", "images") + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """A title to provide for this check run.""" + + summary = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="summary") + """The summary of the check run (supports Commonmark).""" + + text = sgqlc.types.Field(String, graphql_name="text") + """The details of the check run (supports Commonmark).""" + + annotations = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(CheckAnnotationData)), graphql_name="annotations") + """The annotations that are made as part of the check run.""" + + images = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("CheckRunOutputImage")), graphql_name="images") + """Images attached to the check run output displayed in the GitHub + pull request UI. + """ + + +class CheckRunOutputImage(sgqlc.types.Input): + """Images attached to the check run output displayed in the GitHub + pull request UI. + """ + + __schema__ = github_schema + __field_names__ = ("alt", "image_url", "caption") + alt = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="alt") + """The alternative text for the image.""" + + image_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="imageUrl") + """The full URL of the image.""" + + caption = sgqlc.types.Field(String, graphql_name="caption") + """A short image description.""" + + +class CheckSuiteAutoTriggerPreference(sgqlc.types.Input): + """The auto-trigger preferences that are available for check suites.""" + + __schema__ = github_schema + __field_names__ = ("app_id", "setting") + app_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="appId") + """The node ID of the application that owns the check suite.""" + + setting = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="setting") + """Set to `true` to enable automatic creation of CheckSuite events + upon pushes to the repository. + """ + + +class CheckSuiteFilter(sgqlc.types.Input): + """The filters that are available when fetching check suites.""" + + __schema__ = github_schema + __field_names__ = ("app_id", "check_name") + app_id = sgqlc.types.Field(Int, graphql_name="appId") + """Filters the check suites created by this application ID.""" + + check_name = sgqlc.types.Field(String, graphql_name="checkName") + """Filters the check suites by this name.""" + + +class ClearLabelsFromLabelableInput(sgqlc.types.Input): + """Autogenerated input type of ClearLabelsFromLabelable""" + + __schema__ = github_schema + __field_names__ = ("labelable_id", "client_mutation_id") + labelable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="labelableId") + """The id of the labelable object to clear the labels from.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CloneProjectInput(sgqlc.types.Input): + """Autogenerated input type of CloneProject""" + + __schema__ = github_schema + __field_names__ = ("target_owner_id", "source_id", "include_workflows", "name", "body", "public", "client_mutation_id") + target_owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="targetOwnerId") + """The owner ID to create the project under.""" + + source_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="sourceId") + """The source project to clone.""" + + include_workflows = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="includeWorkflows") + """Whether or not to clone the source project's workflows.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the project.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The description of the project.""" + + public = sgqlc.types.Field(Boolean, graphql_name="public") + """The visibility of the project, defaults to false (private).""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CloneTemplateRepositoryInput(sgqlc.types.Input): + """Autogenerated input type of CloneTemplateRepository""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "name", "owner_id", "description", "visibility", "include_all_branches", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the template repository.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the new repository.""" + + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the owner for the new repository.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """A short description of the new repository.""" + + visibility = sgqlc.types.Field(sgqlc.types.non_null(RepositoryVisibility), graphql_name="visibility") + """Indicates the repository's visibility level.""" + + include_all_branches = sgqlc.types.Field(Boolean, graphql_name="includeAllBranches") + """Whether to copy all branches from the template to the new + repository. Defaults to copying only the default branch of the + template. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CloseIssueInput(sgqlc.types.Input): + """Autogenerated input type of CloseIssue""" + + __schema__ = github_schema + __field_names__ = ("issue_id", "state_reason", "client_mutation_id") + issue_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="issueId") + """ID of the issue to be closed.""" + + state_reason = sgqlc.types.Field(IssueClosedStateReason, graphql_name="stateReason") + """The reason the issue is to be closed.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ClosePullRequestInput(sgqlc.types.Input): + """Autogenerated input type of ClosePullRequest""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """ID of the pull request to be closed.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CommitAuthor(sgqlc.types.Input): + """Specifies an author for filtering Git commits.""" + + __schema__ = github_schema + __field_names__ = ("id", "emails") + id = sgqlc.types.Field(ID, graphql_name="id") + """ID of a User to filter by. If non-null, only commits authored by + this user will be returned. This field takes precedence over + emails. + """ + + emails = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="emails") + """Email addresses to filter by. Commits authored by any of the + specified email addresses will be returned. + """ + + +class CommitContributionOrder(sgqlc.types.Input): + """Ordering options for commit contribution connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(CommitContributionOrderField), graphql_name="field") + """The field by which to order commit contributions.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class CommitMessage(sgqlc.types.Input): + """A message to include with a new commit""" + + __schema__ = github_schema + __field_names__ = ("headline", "body") + headline = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="headline") + """The headline of the message.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The body of the message.""" + + +class CommittableBranch(sgqlc.types.Input): + """A git ref for a commit to be appended to. The ref must be a + branch, i.e. its fully qualified name must start with + `refs/heads/` (although the input is not required to be fully + qualified). The Ref may be specified by its global node ID or by + the repository nameWithOwner and branch name. ### Examples + Specify a branch using a global node ID: { "id": + "MDM6UmVmMTpyZWZzL2hlYWRzL21haW4=" } Specify a branch using + nameWithOwner and branch name: { "nameWithOwner": + "github/graphql-client", "branchName": "main" } + """ + + __schema__ = github_schema + __field_names__ = ("id", "repository_name_with_owner", "branch_name") + id = sgqlc.types.Field(ID, graphql_name="id") + """The Node ID of the Ref to be updated.""" + + repository_name_with_owner = sgqlc.types.Field(String, graphql_name="repositoryNameWithOwner") + """The nameWithOwner of the repository to commit to.""" + + branch_name = sgqlc.types.Field(String, graphql_name="branchName") + """The unqualified name of the branch to append the commit to.""" + + +class ContributionOrder(sgqlc.types.Input): + """Ordering options for contribution connections.""" + + __schema__ = github_schema + __field_names__ = ("direction",) + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class ConvertProjectCardNoteToIssueInput(sgqlc.types.Input): + """Autogenerated input type of ConvertProjectCardNoteToIssue""" + + __schema__ = github_schema + __field_names__ = ("project_card_id", "repository_id", "title", "body", "client_mutation_id") + project_card_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectCardId") + """The ProjectCard ID to convert.""" + + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The ID of the repository to create the issue in.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The title of the newly created issue. Defaults to the card's note + text. + """ + + body = sgqlc.types.Field(String, graphql_name="body") + """The body of the newly created issue.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ConvertPullRequestToDraftInput(sgqlc.types.Input): + """Autogenerated input type of ConvertPullRequestToDraft""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """ID of the pull request to convert to draft""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateBranchProtectionRuleInput(sgqlc.types.Input): + """Autogenerated input type of CreateBranchProtectionRule""" + + __schema__ = github_schema + __field_names__ = ( + "repository_id", + "pattern", + "requires_approving_reviews", + "required_approving_review_count", + "requires_commit_signatures", + "requires_linear_history", + "blocks_creations", + "allows_force_pushes", + "allows_deletions", + "is_admin_enforced", + "requires_status_checks", + "requires_strict_status_checks", + "requires_code_owner_reviews", + "dismisses_stale_reviews", + "restricts_review_dismissals", + "review_dismissal_actor_ids", + "bypass_pull_request_actor_ids", + "bypass_force_push_actor_ids", + "restricts_pushes", + "push_actor_ids", + "required_status_check_contexts", + "required_status_checks", + "requires_conversation_resolution", + "client_mutation_id", + ) + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The global relay id of the repository in which a new branch + protection rule should be created in. + """ + + pattern = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="pattern") + """The glob-like pattern used to determine matching branches.""" + + requires_approving_reviews = sgqlc.types.Field(Boolean, graphql_name="requiresApprovingReviews") + """Are approving reviews required to update matching branches.""" + + required_approving_review_count = sgqlc.types.Field(Int, graphql_name="requiredApprovingReviewCount") + """Number of approving reviews required to update matching branches.""" + + requires_commit_signatures = sgqlc.types.Field(Boolean, graphql_name="requiresCommitSignatures") + """Are commits required to be signed.""" + + requires_linear_history = sgqlc.types.Field(Boolean, graphql_name="requiresLinearHistory") + """Are merge commits prohibited from being pushed to this branch.""" + + blocks_creations = sgqlc.types.Field(Boolean, graphql_name="blocksCreations") + """Is branch creation a protected operation.""" + + allows_force_pushes = sgqlc.types.Field(Boolean, graphql_name="allowsForcePushes") + """Are force pushes allowed on this branch.""" + + allows_deletions = sgqlc.types.Field(Boolean, graphql_name="allowsDeletions") + """Can this branch be deleted.""" + + is_admin_enforced = sgqlc.types.Field(Boolean, graphql_name="isAdminEnforced") + """Can admins overwrite branch protection.""" + + requires_status_checks = sgqlc.types.Field(Boolean, graphql_name="requiresStatusChecks") + """Are status checks required to update matching branches.""" + + requires_strict_status_checks = sgqlc.types.Field(Boolean, graphql_name="requiresStrictStatusChecks") + """Are branches required to be up to date before merging.""" + + requires_code_owner_reviews = sgqlc.types.Field(Boolean, graphql_name="requiresCodeOwnerReviews") + """Are reviews from code owners required to update matching branches.""" + + dismisses_stale_reviews = sgqlc.types.Field(Boolean, graphql_name="dismissesStaleReviews") + """Will new commits pushed to matching branches dismiss pull request + review approvals. + """ + + restricts_review_dismissals = sgqlc.types.Field(Boolean, graphql_name="restrictsReviewDismissals") + """Is dismissal of pull request reviews restricted.""" + + review_dismissal_actor_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="reviewDismissalActorIds") + """A list of User, Team, or App IDs allowed to dismiss reviews on + pull requests targeting matching branches. + """ + + bypass_pull_request_actor_ids = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="bypassPullRequestActorIds" + ) + """A list of User, Team, or App IDs allowed to bypass pull requests + targeting matching branches. + """ + + bypass_force_push_actor_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="bypassForcePushActorIds") + """A list of User, Team, or App IDs allowed to bypass force push + targeting matching branches. + """ + + restricts_pushes = sgqlc.types.Field(Boolean, graphql_name="restrictsPushes") + """Is pushing to matching branches restricted.""" + + push_actor_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="pushActorIds") + """A list of User, Team, or App IDs allowed to push to matching + branches. + """ + + required_status_check_contexts = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="requiredStatusCheckContexts" + ) + """List of required status check contexts that must pass for commits + to be accepted to matching branches. + """ + + required_status_checks = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null("RequiredStatusCheckInput")), graphql_name="requiredStatusChecks" + ) + """The list of required status checks""" + + requires_conversation_resolution = sgqlc.types.Field(Boolean, graphql_name="requiresConversationResolution") + """Are conversations required to be resolved before merging.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateCheckRunInput(sgqlc.types.Input): + """Autogenerated input type of CreateCheckRun""" + + __schema__ = github_schema + __field_names__ = ( + "repository_id", + "name", + "head_sha", + "details_url", + "external_id", + "status", + "started_at", + "conclusion", + "completed_at", + "output", + "actions", + "client_mutation_id", + ) + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The node ID of the repository.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the check.""" + + head_sha = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="headSha") + """The SHA of the head commit.""" + + details_url = sgqlc.types.Field(URI, graphql_name="detailsUrl") + """The URL of the integrator's site that has the full details of the + check. + """ + + external_id = sgqlc.types.Field(String, graphql_name="externalId") + """A reference for the run on the integrator's system.""" + + status = sgqlc.types.Field(RequestableCheckStatusState, graphql_name="status") + """The current status.""" + + started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt") + """The time that the check run began.""" + + conclusion = sgqlc.types.Field(CheckConclusionState, graphql_name="conclusion") + """The final conclusion of the check.""" + + completed_at = sgqlc.types.Field(DateTime, graphql_name="completedAt") + """The time that the check run finished.""" + + output = sgqlc.types.Field(CheckRunOutput, graphql_name="output") + """Descriptive details about the run.""" + + actions = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(CheckRunAction)), graphql_name="actions") + """Possible further actions the integrator can perform, which a user + may trigger. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateCheckSuiteInput(sgqlc.types.Input): + """Autogenerated input type of CreateCheckSuite""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "head_sha", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + head_sha = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="headSha") + """The SHA of the head commit.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateCommitOnBranchInput(sgqlc.types.Input): + """Autogenerated input type of CreateCommitOnBranch""" + + __schema__ = github_schema + __field_names__ = ("branch", "file_changes", "message", "expected_head_oid", "client_mutation_id") + branch = sgqlc.types.Field(sgqlc.types.non_null(CommittableBranch), graphql_name="branch") + """The Ref to be updated. Must be a branch.""" + + file_changes = sgqlc.types.Field("FileChanges", graphql_name="fileChanges") + """A description of changes to files in this commit.""" + + message = sgqlc.types.Field(sgqlc.types.non_null(CommitMessage), graphql_name="message") + """The commit message the be included with the commit.""" + + expected_head_oid = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="expectedHeadOid") + """The git commit oid expected at the head of the branch prior to the + commit + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateDiscussionInput(sgqlc.types.Input): + """Autogenerated input type of CreateDiscussion""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "title", "body", "category_id", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The id of the repository on which to create the discussion.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the discussion.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The body of the discussion.""" + + category_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="categoryId") + """The id of the discussion category to associate with this + discussion. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateEnterpriseOrganizationInput(sgqlc.types.Input): + """Autogenerated input type of CreateEnterpriseOrganization""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "login", "profile_name", "billing_email", "admin_logins", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise owning the new organization.""" + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of the new organization.""" + + profile_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="profileName") + """The profile name of the new organization.""" + + billing_email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="billingEmail") + """The email used for sending billing receipts.""" + + admin_logins = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))), graphql_name="adminLogins") + """The logins for the administrators of the new organization.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateEnvironmentInput(sgqlc.types.Input): + """Autogenerated input type of CreateEnvironment""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "name", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The node ID of the repository.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the environment.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateIpAllowListEntryInput(sgqlc.types.Input): + """Autogenerated input type of CreateIpAllowListEntry""" + + __schema__ = github_schema + __field_names__ = ("owner_id", "allow_list_value", "name", "is_active", "client_mutation_id") + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the owner for which to create the new IP allow list + entry. + """ + + allow_list_value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="allowListValue") + """An IP address or range of addresses in CIDR notation.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """An optional name for the IP allow list entry.""" + + is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive") + """Whether the IP allow list entry is active when an IP allow list is + enabled. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateIssueInput(sgqlc.types.Input): + """Autogenerated input type of CreateIssue""" + + __schema__ = github_schema + __field_names__ = ( + "repository_id", + "title", + "body", + "assignee_ids", + "milestone_id", + "label_ids", + "project_ids", + "issue_template", + "client_mutation_id", + ) + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title for the issue.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The body for the issue description.""" + + assignee_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="assigneeIds") + """The Node ID for the user assignee for this issue.""" + + milestone_id = sgqlc.types.Field(ID, graphql_name="milestoneId") + """The Node ID of the milestone for this issue.""" + + label_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="labelIds") + """An array of Node IDs of labels for this issue.""" + + project_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="projectIds") + """An array of Node IDs for projects associated with this issue.""" + + issue_template = sgqlc.types.Field(String, graphql_name="issueTemplate") + """The name of an issue template in the repository, assigns labels + and assignees from the template to the issue + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateMigrationSourceInput(sgqlc.types.Input): + """Autogenerated input type of CreateMigrationSource""" + + __schema__ = github_schema + __field_names__ = ("name", "url", "access_token", "type", "owner_id", "github_pat", "client_mutation_id") + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The Octoshift migration source name.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="url") + """The Octoshift migration source URL.""" + + access_token = sgqlc.types.Field(String, graphql_name="accessToken") + """The Octoshift migration source access token.""" + + type = sgqlc.types.Field(sgqlc.types.non_null(MigrationSourceType), graphql_name="type") + """The Octoshift migration source type.""" + + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the organization that will own the Octoshift migration + source. + """ + + github_pat = sgqlc.types.Field(String, graphql_name="githubPat") + """The GitHub personal access token of the user importing to the + target repository. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateProjectInput(sgqlc.types.Input): + """Autogenerated input type of CreateProject""" + + __schema__ = github_schema + __field_names__ = ("owner_id", "name", "body", "template", "repository_ids", "client_mutation_id") + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The owner ID to create the project under.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of project.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The description of project.""" + + template = sgqlc.types.Field(ProjectTemplate, graphql_name="template") + """The name of the GitHub-provided template.""" + + repository_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="repositoryIds") + """A list of repository IDs to create as linked repositories for the + project + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreatePullRequestInput(sgqlc.types.Input): + """Autogenerated input type of CreatePullRequest""" + + __schema__ = github_schema + __field_names__ = ( + "repository_id", + "base_ref_name", + "head_ref_name", + "title", + "body", + "maintainer_can_modify", + "draft", + "client_mutation_id", + ) + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + base_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="baseRefName") + """The name of the branch you want your changes pulled into. This + should be an existing branch on the current repository. You cannot + update the base branch on a pull request to point to another + repository. + """ + + head_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="headRefName") + """The name of the branch where your changes are implemented. For + cross-repository pull requests in the same network, namespace + `head_ref_name` with a user like this: `username:branch`. + """ + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the pull request.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The contents of the pull request.""" + + maintainer_can_modify = sgqlc.types.Field(Boolean, graphql_name="maintainerCanModify") + """Indicates whether maintainers can modify the pull request.""" + + draft = sgqlc.types.Field(Boolean, graphql_name="draft") + """Indicates whether this pull request should be a draft.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateRefInput(sgqlc.types.Input): + """Autogenerated input type of CreateRef""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "name", "oid", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the Repository to create the Ref in.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The fully qualified name of the new Ref (ie: + `refs/heads/my_new_branch`). + """ + + oid = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="oid") + """The GitObjectID that the new Ref shall target. Must point to a + commit. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateRepositoryInput(sgqlc.types.Input): + """Autogenerated input type of CreateRepository""" + + __schema__ = github_schema + __field_names__ = ( + "name", + "owner_id", + "description", + "visibility", + "template", + "homepage_url", + "has_wiki_enabled", + "has_issues_enabled", + "team_id", + "client_mutation_id", + ) + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the new repository.""" + + owner_id = sgqlc.types.Field(ID, graphql_name="ownerId") + """The ID of the owner for the new repository.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """A short description of the new repository.""" + + visibility = sgqlc.types.Field(sgqlc.types.non_null(RepositoryVisibility), graphql_name="visibility") + """Indicates the repository's visibility level.""" + + template = sgqlc.types.Field(Boolean, graphql_name="template") + """Whether this repository should be marked as a template such that + anyone who can access it can create new repositories with the same + files and directory structure. + """ + + homepage_url = sgqlc.types.Field(URI, graphql_name="homepageUrl") + """The URL for a web page about this repository.""" + + has_wiki_enabled = sgqlc.types.Field(Boolean, graphql_name="hasWikiEnabled") + """Indicates if the repository should have the wiki feature enabled.""" + + has_issues_enabled = sgqlc.types.Field(Boolean, graphql_name="hasIssuesEnabled") + """Indicates if the repository should have the issues feature + enabled. + """ + + team_id = sgqlc.types.Field(ID, graphql_name="teamId") + """When an organization is specified as the owner, this ID identifies + the team that should be granted access to the new repository. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateSponsorsTierInput(sgqlc.types.Input): + """Autogenerated input type of CreateSponsorsTier""" + + __schema__ = github_schema + __field_names__ = ( + "sponsorable_id", + "sponsorable_login", + "amount", + "is_recurring", + "repository_id", + "repository_owner_login", + "repository_name", + "welcome_message", + "description", + "publish", + "client_mutation_id", + ) + sponsorable_id = sgqlc.types.Field(ID, graphql_name="sponsorableId") + """The ID of the user or organization who owns the GitHub Sponsors + profile. Defaults to the current user if omitted and + sponsorableLogin is not given. + """ + + sponsorable_login = sgqlc.types.Field(String, graphql_name="sponsorableLogin") + """The username of the user or organization who owns the GitHub + Sponsors profile. Defaults to the current user if omitted and + sponsorableId is not given. + """ + + amount = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="amount") + """The value of the new tier in US dollars. Valid values: 1-12000.""" + + is_recurring = sgqlc.types.Field(Boolean, graphql_name="isRecurring") + """Whether sponsorships using this tier should happen monthly/yearly + or just once. + """ + + repository_id = sgqlc.types.Field(ID, graphql_name="repositoryId") + """Optional ID of the private repository that sponsors at this tier + should gain read-only access to. Must be owned by an organization. + """ + + repository_owner_login = sgqlc.types.Field(String, graphql_name="repositoryOwnerLogin") + """Optional login of the organization owner of the private repository + that sponsors at this tier should gain read-only access to. + Necessary if repositoryName is given. Will be ignored if + repositoryId is given. + """ + + repository_name = sgqlc.types.Field(String, graphql_name="repositoryName") + """Optional name of the private repository that sponsors at this tier + should gain read-only access to. Must be owned by an organization. + Necessary if repositoryOwnerLogin is given. Will be ignored if + repositoryId is given. + """ + + welcome_message = sgqlc.types.Field(String, graphql_name="welcomeMessage") + """Optional message new sponsors at this tier will receive.""" + + description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description") + """A description of what this tier is, what perks sponsors might + receive, what a sponsorship at this tier means for you, etc. + """ + + publish = sgqlc.types.Field(Boolean, graphql_name="publish") + """Whether to make the tier available immediately for sponsors to + choose. Defaults to creating a draft tier that will not be + publicly visible. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateSponsorshipInput(sgqlc.types.Input): + """Autogenerated input type of CreateSponsorship""" + + __schema__ = github_schema + __field_names__ = ( + "sponsor_id", + "sponsor_login", + "sponsorable_id", + "sponsorable_login", + "tier_id", + "amount", + "is_recurring", + "receive_emails", + "privacy_level", + "client_mutation_id", + ) + sponsor_id = sgqlc.types.Field(ID, graphql_name="sponsorId") + """The ID of the user or organization who is acting as the sponsor, + paying for the sponsorship. Required if sponsorLogin is not given. + """ + + sponsor_login = sgqlc.types.Field(String, graphql_name="sponsorLogin") + """The username of the user or organization who is acting as the + sponsor, paying for the sponsorship. Required if sponsorId is not + given. + """ + + sponsorable_id = sgqlc.types.Field(ID, graphql_name="sponsorableId") + """The ID of the user or organization who is receiving the + sponsorship. Required if sponsorableLogin is not given. + """ + + sponsorable_login = sgqlc.types.Field(String, graphql_name="sponsorableLogin") + """The username of the user or organization who is receiving the + sponsorship. Required if sponsorableId is not given. + """ + + tier_id = sgqlc.types.Field(ID, graphql_name="tierId") + """The ID of one of sponsorable's existing tiers to sponsor at. + Required if amount is not specified. + """ + + amount = sgqlc.types.Field(Int, graphql_name="amount") + """The amount to pay to the sponsorable in US dollars. Required if a + tierId is not specified. Valid values: 1-12000. + """ + + is_recurring = sgqlc.types.Field(Boolean, graphql_name="isRecurring") + """Whether the sponsorship should happen monthly/yearly or just this + one time. Required if a tierId is not specified. + """ + + receive_emails = sgqlc.types.Field(Boolean, graphql_name="receiveEmails") + """Whether the sponsor should receive email updates from the + sponsorable. + """ + + privacy_level = sgqlc.types.Field(SponsorshipPrivacy, graphql_name="privacyLevel") + """Specify whether others should be able to see that the sponsor is + sponsoring the sponsorable. Public visibility still does not + reveal which tier is used. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateTeamDiscussionCommentInput(sgqlc.types.Input): + """Autogenerated input type of CreateTeamDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("discussion_id", "body", "client_mutation_id") + discussion_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="discussionId") + """The ID of the discussion to which the comment belongs.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The content of the comment.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateTeamDiscussionInput(sgqlc.types.Input): + """Autogenerated input type of CreateTeamDiscussion""" + + __schema__ = github_schema + __field_names__ = ("team_id", "title", "body", "private", "client_mutation_id") + team_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="teamId") + """The ID of the team to which the discussion belongs.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the discussion.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The content of the discussion.""" + + private = sgqlc.types.Field(Boolean, graphql_name="private") + """If true, restricts the visibility of this discussion to team + members and organization admins. If false or not specified, allows + any organization member to view this discussion. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeclineTopicSuggestionInput(sgqlc.types.Input): + """Autogenerated input type of DeclineTopicSuggestion""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "name", "reason", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the suggested topic.""" + + reason = sgqlc.types.Field(sgqlc.types.non_null(TopicSuggestionDeclineReason), graphql_name="reason") + """The reason why the suggested topic is declined.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteBranchProtectionRuleInput(sgqlc.types.Input): + """Autogenerated input type of DeleteBranchProtectionRule""" + + __schema__ = github_schema + __field_names__ = ("branch_protection_rule_id", "client_mutation_id") + branch_protection_rule_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="branchProtectionRuleId") + """The global relay id of the branch protection rule to be deleted.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteDeploymentInput(sgqlc.types.Input): + """Autogenerated input type of DeleteDeployment""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The Node ID of the deployment to be deleted.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteDiscussionCommentInput(sgqlc.types.Input): + """Autogenerated input type of DeleteDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The Node id of the discussion comment to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteDiscussionInput(sgqlc.types.Input): + """Autogenerated input type of DeleteDiscussion""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The id of the discussion to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteEnvironmentInput(sgqlc.types.Input): + """Autogenerated input type of DeleteEnvironment""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The Node ID of the environment to be deleted.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteIpAllowListEntryInput(sgqlc.types.Input): + """Autogenerated input type of DeleteIpAllowListEntry""" + + __schema__ = github_schema + __field_names__ = ("ip_allow_list_entry_id", "client_mutation_id") + ip_allow_list_entry_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ipAllowListEntryId") + """The ID of the IP allow list entry to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteIssueCommentInput(sgqlc.types.Input): + """Autogenerated input type of DeleteIssueComment""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the comment to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteIssueInput(sgqlc.types.Input): + """Autogenerated input type of DeleteIssue""" + + __schema__ = github_schema + __field_names__ = ("issue_id", "client_mutation_id") + issue_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="issueId") + """The ID of the issue to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteProjectCardInput(sgqlc.types.Input): + """Autogenerated input type of DeleteProjectCard""" + + __schema__ = github_schema + __field_names__ = ("card_id", "client_mutation_id") + card_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="cardId") + """The id of the card to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteProjectColumnInput(sgqlc.types.Input): + """Autogenerated input type of DeleteProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("column_id", "client_mutation_id") + column_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="columnId") + """The id of the column to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteProjectInput(sgqlc.types.Input): + """Autogenerated input type of DeleteProject""" + + __schema__ = github_schema + __field_names__ = ("project_id", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The Project ID to update.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteProjectNextItemInput(sgqlc.types.Input): + """Autogenerated input type of DeleteProjectNextItem""" + + __schema__ = github_schema + __field_names__ = ("project_id", "item_id", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The ID of the Project from which the item should be removed.""" + + item_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="itemId") + """The ID of the item to be removed.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeletePullRequestReviewCommentInput(sgqlc.types.Input): + """Autogenerated input type of DeletePullRequestReviewComment""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the comment to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeletePullRequestReviewInput(sgqlc.types.Input): + """Autogenerated input type of DeletePullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("pull_request_review_id", "client_mutation_id") + pull_request_review_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestReviewId") + """The Node ID of the pull request review to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteRefInput(sgqlc.types.Input): + """Autogenerated input type of DeleteRef""" + + __schema__ = github_schema + __field_names__ = ("ref_id", "client_mutation_id") + ref_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="refId") + """The Node ID of the Ref to be deleted.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteTeamDiscussionCommentInput(sgqlc.types.Input): + """Autogenerated input type of DeleteTeamDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the comment to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteTeamDiscussionInput(sgqlc.types.Input): + """Autogenerated input type of DeleteTeamDiscussion""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The discussion ID to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteVerifiableDomainInput(sgqlc.types.Input): + """Autogenerated input type of DeleteVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the verifiable domain to delete.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeploymentOrder(sgqlc.types.Input): + """Ordering options for deployment connections""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(DeploymentOrderField), graphql_name="field") + """The field to order deployments by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class DisablePullRequestAutoMergeInput(sgqlc.types.Input): + """Autogenerated input type of DisablePullRequestAutoMerge""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """ID of the pull request to disable auto merge on.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DiscussionOrder(sgqlc.types.Input): + """Ways in which lists of discussions can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(DiscussionOrderField), graphql_name="field") + """The field by which to order discussions.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order discussions by the specified + field. + """ + + +class DiscussionPollOptionOrder(sgqlc.types.Input): + """Ordering options for discussion poll option connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(DiscussionPollOptionOrderField), graphql_name="field") + """The field to order poll options by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class DismissPullRequestReviewInput(sgqlc.types.Input): + """Autogenerated input type of DismissPullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("pull_request_review_id", "message", "client_mutation_id") + pull_request_review_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestReviewId") + """The Node ID of the pull request review to modify.""" + + message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message") + """The contents of the pull request review dismissal message.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DismissRepositoryVulnerabilityAlertInput(sgqlc.types.Input): + """Autogenerated input type of DismissRepositoryVulnerabilityAlert""" + + __schema__ = github_schema + __field_names__ = ("repository_vulnerability_alert_id", "dismiss_reason", "client_mutation_id") + repository_vulnerability_alert_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryVulnerabilityAlertId") + """The Dependabot alert ID to dismiss.""" + + dismiss_reason = sgqlc.types.Field(sgqlc.types.non_null(DismissReason), graphql_name="dismissReason") + """The reason the Dependabot alert is being dismissed.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DraftPullRequestReviewComment(sgqlc.types.Input): + """Specifies a review comment to be left with a Pull Request Review.""" + + __schema__ = github_schema + __field_names__ = ("path", "position", "body") + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """Path to the file being commented on.""" + + position = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="position") + """Position in the file to leave a comment on.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """Body of the comment to leave.""" + + +class DraftPullRequestReviewThread(sgqlc.types.Input): + """Specifies a review comment thread to be left with a Pull Request + Review. + """ + + __schema__ = github_schema + __field_names__ = ("path", "line", "side", "start_line", "start_side", "body") + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """Path to the file being commented on.""" + + line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="line") + """The line of the blob to which the thread refers. The end of the + line range for multi-line comments. + """ + + side = sgqlc.types.Field(DiffSide, graphql_name="side") + """The side of the diff on which the line resides. For multi-line + comments, this is the side for the end of the line range. + """ + + start_line = sgqlc.types.Field(Int, graphql_name="startLine") + """The first line of the range to which the comment refers.""" + + start_side = sgqlc.types.Field(DiffSide, graphql_name="startSide") + """The side of the diff on which the start line resides.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """Body of the comment to leave.""" + + +class EnablePullRequestAutoMergeInput(sgqlc.types.Input): + """Autogenerated input type of EnablePullRequestAutoMerge""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "commit_headline", "commit_body", "merge_method", "author_email", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """ID of the pull request to enable auto-merge on.""" + + commit_headline = sgqlc.types.Field(String, graphql_name="commitHeadline") + """Commit headline to use for the commit when the PR is mergable; if + omitted, a default message will be used. + """ + + commit_body = sgqlc.types.Field(String, graphql_name="commitBody") + """Commit body to use for the commit when the PR is mergable; if + omitted, a default message will be used. + """ + + merge_method = sgqlc.types.Field(PullRequestMergeMethod, graphql_name="mergeMethod") + """The merge method to use. If omitted, defaults to 'MERGE' """ + + author_email = sgqlc.types.Field(String, graphql_name="authorEmail") + """The email address to associate with this merge.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class EnterpriseAdministratorInvitationOrder(sgqlc.types.Input): + """Ordering options for enterprise administrator invitation + connections + """ + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseAdministratorInvitationOrderField), graphql_name="field") + """The field to order enterprise administrator invitations by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class EnterpriseMemberOrder(sgqlc.types.Input): + """Ordering options for enterprise member connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseMemberOrderField), graphql_name="field") + """The field to order enterprise members by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class EnterpriseServerInstallationOrder(sgqlc.types.Input): + """Ordering options for Enterprise Server installation connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseServerInstallationOrderField), graphql_name="field") + """The field to order Enterprise Server installations by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class EnterpriseServerUserAccountEmailOrder(sgqlc.types.Input): + """Ordering options for Enterprise Server user account email + connections. + """ + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseServerUserAccountEmailOrderField), graphql_name="field") + """The field to order emails by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class EnterpriseServerUserAccountOrder(sgqlc.types.Input): + """Ordering options for Enterprise Server user account connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseServerUserAccountOrderField), graphql_name="field") + """The field to order user accounts by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class EnterpriseServerUserAccountsUploadOrder(sgqlc.types.Input): + """Ordering options for Enterprise Server user accounts upload + connections. + """ + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseServerUserAccountsUploadOrderField), graphql_name="field") + """The field to order user accounts uploads by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class FileAddition(sgqlc.types.Input): + """A command to add a file at the given path with the given contents + as part of a commit. Any existing file at that that path will be + replaced. + """ + + __schema__ = github_schema + __field_names__ = ("path", "contents") + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path in the repository where the file will be located""" + + contents = sgqlc.types.Field(sgqlc.types.non_null(Base64String), graphql_name="contents") + """The base64 encoded contents of the file""" + + +class FileChanges(sgqlc.types.Input): + """A description of a set of changes to a file tree to be made as + part of a git commit, modeled as zero or more file `additions` and + zero or more file `deletions`. Both fields are optional; omitting + both will produce a commit with no file changes. `deletions` and + `additions` describe changes to files identified by their path in + the git tree using unix-style path separators, i.e. `/`. The root + of a git tree is an empty string, so paths are not slash-prefixed. + `path` values must be unique across all `additions` and + `deletions` provided. Any duplication will result in a validation + error. ### Encoding File contents must be provided in full for + each `FileAddition`. The `contents` of a `FileAddition` must be + encoded using RFC 4648 compliant base64, i.e. correct padding is + required and no characters outside the standard alphabet may be + used. Invalid base64 encoding will be rejected with a validation + error. The encoded contents may be binary. For text files, no + assumptions are made about the character encoding of the file + contents (after base64 decoding). No charset transcoding or line- + ending normalization will be performed; it is the client's + responsibility to manage the character encoding of files they + provide. However, for maximum compatibility we recommend using + UTF-8 encoding and ensuring that all files in a repository use a + consistent line-ending convention (`\n` or `\r\n`), and that all + files end with a newline. ### Modeling file changes Each of the + the five types of conceptual changes that can be made in a git + commit can be described using the `FileChanges` type as follows: + 1. New file addition: create file `hello world\n` at path + `docs/README.txt`: { "additions" [ { + "path": "docs/README.txt", "contents": + base64encode("hello world\n") } ] } 2. + Existing file modification: change existing `docs/README.txt` to + have new content `new content here\n`: { + "additions" [ { "path": "docs/README.txt", + "contents": base64encode("new content here\n") } + ] } 3. Existing file deletion: remove existing file + `docs/README.txt`. Note that the path is required to exist -- + specifying a path that does not exist on the given branch will + abort the commit and return an error. { + "deletions" [ { "path": "docs/README.txt" + } ] } 4. File rename with no changes: rename + `docs/README.txt` with previous content `hello world\n` to the + same content at `newdocs/README.txt`: { + "deletions" [ { "path": "docs/README.txt", + } ], "additions" [ { + "path": "newdocs/README.txt", "contents": + base64encode("hello world\n") } ] } + 5. File rename with changes: rename `docs/README.txt` with + previous content `hello world\n` to a file at path + `newdocs/README.txt` with content `new contents\n`: { + "deletions" [ { "path": "docs/README.txt", + } ], "additions" [ { + "path": "newdocs/README.txt", "contents": + base64encode("new contents\n") } ] } + """ + + __schema__ = github_schema + __field_names__ = ("deletions", "additions") + deletions = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("FileDeletion")), graphql_name="deletions") + """Files to delete.""" + + additions = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(FileAddition)), graphql_name="additions") + """File to add or change.""" + + +class FileDeletion(sgqlc.types.Input): + """A command to delete the file at the given path as part of a + commit. + """ + + __schema__ = github_schema + __field_names__ = ("path",) + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path to delete""" + + +class FollowOrganizationInput(sgqlc.types.Input): + """Autogenerated input type of FollowOrganization""" + + __schema__ = github_schema + __field_names__ = ("organization_id", "client_mutation_id") + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """ID of the organization to follow.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class FollowUserInput(sgqlc.types.Input): + """Autogenerated input type of FollowUser""" + + __schema__ = github_schema + __field_names__ = ("user_id", "client_mutation_id") + user_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="userId") + """ID of the user to follow.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class GistOrder(sgqlc.types.Input): + """Ordering options for gist connections""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(GistOrderField), graphql_name="field") + """The field to order repositories by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class GrantEnterpriseOrganizationsMigratorRoleInput(sgqlc.types.Input): + """Autogenerated input type of + GrantEnterpriseOrganizationsMigratorRole + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "login", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise to which all organizations managed by it + will be granted the migrator role. + """ + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of the user to grant the migrator role""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class GrantMigratorRoleInput(sgqlc.types.Input): + """Autogenerated input type of GrantMigratorRole""" + + __schema__ = github_schema + __field_names__ = ("organization_id", "actor", "actor_type", "client_mutation_id") + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """The ID of the organization that the user/team belongs to.""" + + actor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="actor") + """The user login or Team slug to grant the migrator role.""" + + actor_type = sgqlc.types.Field(sgqlc.types.non_null(ActorType), graphql_name="actorType") + """Specifies the type of the actor, can be either USER or TEAM.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class InviteEnterpriseAdminInput(sgqlc.types.Input): + """Autogenerated input type of InviteEnterpriseAdmin""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "invitee", "email", "role", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise to which you want to invite an + administrator. + """ + + invitee = sgqlc.types.Field(String, graphql_name="invitee") + """The login of a user to invite as an administrator.""" + + email = sgqlc.types.Field(String, graphql_name="email") + """The email of the person to invite as an administrator.""" + + role = sgqlc.types.Field(EnterpriseAdministratorRole, graphql_name="role") + """The role of the administrator.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class IpAllowListEntryOrder(sgqlc.types.Input): + """Ordering options for IP allow list entry connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(IpAllowListEntryOrderField), graphql_name="field") + """The field to order IP allow list entries by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class IssueCommentOrder(sgqlc.types.Input): + """Ways in which lists of issue comments can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(IssueCommentOrderField), graphql_name="field") + """The field in which to order issue comments by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order issue comments by the specified + field. + """ + + +class IssueFilters(sgqlc.types.Input): + """Ways in which to filter lists of issues.""" + + __schema__ = github_schema + __field_names__ = ( + "assignee", + "created_by", + "labels", + "mentioned", + "milestone", + "milestone_number", + "since", + "states", + "viewer_subscribed", + ) + assignee = sgqlc.types.Field(String, graphql_name="assignee") + """List issues assigned to given name. Pass in `null` for issues with + no assigned user, and `*` for issues assigned to any user. + """ + + created_by = sgqlc.types.Field(String, graphql_name="createdBy") + """List issues created by given name.""" + + labels = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels") + """List issues where the list of label names exist on the issue.""" + + mentioned = sgqlc.types.Field(String, graphql_name="mentioned") + """List issues where the given name is mentioned in the issue.""" + + milestone = sgqlc.types.Field(String, graphql_name="milestone") + """List issues by given milestone argument. If an string + representation of an integer is passed, it should refer to a + milestone by its database ID. Pass in `null` for issues with no + milestone, and `*` for issues that are assigned to any milestone. + """ + + milestone_number = sgqlc.types.Field(String, graphql_name="milestoneNumber") + """List issues by given milestone argument. If an string + representation of an integer is passed, it should refer to a + milestone by its number field. Pass in `null` for issues with no + milestone, and `*` for issues that are assigned to any milestone. + """ + + since = sgqlc.types.Field(DateTime, graphql_name="since") + """List issues that have been updated at or after the given date.""" + + states = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(IssueState)), graphql_name="states") + """List issues filtered by the list of states given.""" + + viewer_subscribed = sgqlc.types.Field(Boolean, graphql_name="viewerSubscribed") + """List issues subscribed to by viewer.""" + + +class IssueOrder(sgqlc.types.Input): + """Ways in which lists of issues can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(IssueOrderField), graphql_name="field") + """The field in which to order issues by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order issues by the specified field.""" + + +class LabelOrder(sgqlc.types.Input): + """Ways in which lists of labels can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(LabelOrderField), graphql_name="field") + """The field in which to order labels by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order labels by the specified field.""" + + +class LanguageOrder(sgqlc.types.Input): + """Ordering options for language connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(LanguageOrderField), graphql_name="field") + """The field to order languages by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class LinkRepositoryToProjectInput(sgqlc.types.Input): + """Autogenerated input type of LinkRepositoryToProject""" + + __schema__ = github_schema + __field_names__ = ("project_id", "repository_id", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The ID of the Project to link to a Repository""" + + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The ID of the Repository to link to a Project.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class LockLockableInput(sgqlc.types.Input): + """Autogenerated input type of LockLockable""" + + __schema__ = github_schema + __field_names__ = ("lockable_id", "lock_reason", "client_mutation_id") + lockable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="lockableId") + """ID of the item to be locked.""" + + lock_reason = sgqlc.types.Field(LockReason, graphql_name="lockReason") + """A reason for why the item will be locked.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MarkDiscussionCommentAsAnswerInput(sgqlc.types.Input): + """Autogenerated input type of MarkDiscussionCommentAsAnswer""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The Node ID of the discussion comment to mark as an answer.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MarkFileAsViewedInput(sgqlc.types.Input): + """Autogenerated input type of MarkFileAsViewed""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "path", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """The Node ID of the pull request.""" + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path of the file to mark as viewed""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MarkPullRequestReadyForReviewInput(sgqlc.types.Input): + """Autogenerated input type of MarkPullRequestReadyForReview""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """ID of the pull request to be marked as ready for review.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MergeBranchInput(sgqlc.types.Input): + """Autogenerated input type of MergeBranch""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "base", "head", "commit_message", "author_email", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the Repository containing the base branch that will + be modified. + """ + + base = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="base") + """The name of the base branch that the provided head will be merged + into. + """ + + head = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="head") + """The head to merge into the base branch. This can be a branch name + or a commit GitObjectID. + """ + + commit_message = sgqlc.types.Field(String, graphql_name="commitMessage") + """Message to use for the merge commit. If omitted, a default will be + used. + """ + + author_email = sgqlc.types.Field(String, graphql_name="authorEmail") + """The email address to associate with this commit.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MergePullRequestInput(sgqlc.types.Input): + """Autogenerated input type of MergePullRequest""" + + __schema__ = github_schema + __field_names__ = ( + "pull_request_id", + "commit_headline", + "commit_body", + "expected_head_oid", + "merge_method", + "author_email", + "client_mutation_id", + ) + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """ID of the pull request to be merged.""" + + commit_headline = sgqlc.types.Field(String, graphql_name="commitHeadline") + """Commit headline to use for the merge commit; if omitted, a default + message will be used. + """ + + commit_body = sgqlc.types.Field(String, graphql_name="commitBody") + """Commit body to use for the merge commit; if omitted, a default + message will be used + """ + + expected_head_oid = sgqlc.types.Field(GitObjectID, graphql_name="expectedHeadOid") + """OID that the pull request head ref must match to allow merge; if + omitted, no check is performed. + """ + + merge_method = sgqlc.types.Field(PullRequestMergeMethod, graphql_name="mergeMethod") + """The merge method to use. If omitted, defaults to 'MERGE' """ + + author_email = sgqlc.types.Field(String, graphql_name="authorEmail") + """The email address to associate with this merge.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MilestoneOrder(sgqlc.types.Input): + """Ordering options for milestone connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(MilestoneOrderField), graphql_name="field") + """The field to order milestones by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class MinimizeCommentInput(sgqlc.types.Input): + """Autogenerated input type of MinimizeComment""" + + __schema__ = github_schema + __field_names__ = ("subject_id", "classifier", "client_mutation_id") + subject_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subjectId") + """The Node ID of the subject to modify.""" + + classifier = sgqlc.types.Field(sgqlc.types.non_null(ReportedContentClassifiers), graphql_name="classifier") + """The classification of comment""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MoveProjectCardInput(sgqlc.types.Input): + """Autogenerated input type of MoveProjectCard""" + + __schema__ = github_schema + __field_names__ = ("card_id", "column_id", "after_card_id", "client_mutation_id") + card_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="cardId") + """The id of the card to move.""" + + column_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="columnId") + """The id of the column to move it into.""" + + after_card_id = sgqlc.types.Field(ID, graphql_name="afterCardId") + """Place the new card after the card with this id. Pass null to place + it at the top. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MoveProjectColumnInput(sgqlc.types.Input): + """Autogenerated input type of MoveProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("column_id", "after_column_id", "client_mutation_id") + column_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="columnId") + """The id of the column to move.""" + + after_column_id = sgqlc.types.Field(ID, graphql_name="afterColumnId") + """Place the new column after the column with this id. Pass null to + place it at the front. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class OrgEnterpriseOwnerOrder(sgqlc.types.Input): + """Ordering options for an organization's enterprise owner + connections. + """ + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(OrgEnterpriseOwnerOrderField), graphql_name="field") + """The field to order enterprise owners by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class OrganizationOrder(sgqlc.types.Input): + """Ordering options for organization connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(OrganizationOrderField), graphql_name="field") + """The field to order organizations by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class PackageFileOrder(sgqlc.types.Input): + """Ways in which lists of package files can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(PackageFileOrderField, graphql_name="field") + """The field in which to order package files by.""" + + direction = sgqlc.types.Field(OrderDirection, graphql_name="direction") + """The direction in which to order package files by the specified + field. + """ + + +class PackageOrder(sgqlc.types.Input): + """Ways in which lists of packages can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(PackageOrderField, graphql_name="field") + """The field in which to order packages by.""" + + direction = sgqlc.types.Field(OrderDirection, graphql_name="direction") + """The direction in which to order packages by the specified field.""" + + +class PackageVersionOrder(sgqlc.types.Input): + """Ways in which lists of package versions can be ordered upon + return. + """ + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(PackageVersionOrderField, graphql_name="field") + """The field in which to order package versions by.""" + + direction = sgqlc.types.Field(OrderDirection, graphql_name="direction") + """The direction in which to order package versions by the specified + field. + """ + + +class PinIssueInput(sgqlc.types.Input): + """Autogenerated input type of PinIssue""" + + __schema__ = github_schema + __field_names__ = ("issue_id", "client_mutation_id") + issue_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="issueId") + """The ID of the issue to be pinned""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ProjectOrder(sgqlc.types.Input): + """Ways in which lists of projects can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(ProjectOrderField), graphql_name="field") + """The field in which to order projects by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order projects by the specified field.""" + + +class PullRequestOrder(sgqlc.types.Input): + """Ways in which lists of issues can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(PullRequestOrderField), graphql_name="field") + """The field in which to order pull requests by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order pull requests by the specified + field. + """ + + +class ReactionOrder(sgqlc.types.Input): + """Ways in which lists of reactions can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(ReactionOrderField), graphql_name="field") + """The field in which to order reactions by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order reactions by the specified field.""" + + +class RefOrder(sgqlc.types.Input): + """Ways in which lists of git refs can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(RefOrderField), graphql_name="field") + """The field in which to order refs by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order refs by the specified field.""" + + +class RegenerateEnterpriseIdentityProviderRecoveryCodesInput(sgqlc.types.Input): + """Autogenerated input type of + RegenerateEnterpriseIdentityProviderRecoveryCodes + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set an identity provider.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RegenerateVerifiableDomainTokenInput(sgqlc.types.Input): + """Autogenerated input type of RegenerateVerifiableDomainToken""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the verifiable domain to regenerate the verification + token of. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RejectDeploymentsInput(sgqlc.types.Input): + """Autogenerated input type of RejectDeployments""" + + __schema__ = github_schema + __field_names__ = ("workflow_run_id", "environment_ids", "comment", "client_mutation_id") + workflow_run_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="workflowRunId") + """The node ID of the workflow run containing the pending + deployments. + """ + + environment_ids = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="environmentIds") + """The ids of environments to reject deployments""" + + comment = sgqlc.types.Field(String, graphql_name="comment") + """Optional comment for rejecting deployments""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ReleaseOrder(sgqlc.types.Input): + """Ways in which lists of releases can be ordered upon return.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(ReleaseOrderField), graphql_name="field") + """The field in which to order releases by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order releases by the specified field.""" + + +class RemoveAssigneesFromAssignableInput(sgqlc.types.Input): + """Autogenerated input type of RemoveAssigneesFromAssignable""" + + __schema__ = github_schema + __field_names__ = ("assignable_id", "assignee_ids", "client_mutation_id") + assignable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="assignableId") + """The id of the assignable object to remove assignees from.""" + + assignee_ids = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="assigneeIds") + """The id of users to remove as assignees.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveEnterpriseAdminInput(sgqlc.types.Input): + """Autogenerated input type of RemoveEnterpriseAdmin""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "login", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The Enterprise ID from which to remove the administrator.""" + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of the user to remove as an administrator.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveEnterpriseIdentityProviderInput(sgqlc.types.Input): + """Autogenerated input type of RemoveEnterpriseIdentityProvider""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise from which to remove the identity + provider. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveEnterpriseOrganizationInput(sgqlc.types.Input): + """Autogenerated input type of RemoveEnterpriseOrganization""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "organization_id", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise from which the organization should be + removed. + """ + + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """The ID of the organization to remove from the enterprise.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveEnterpriseSupportEntitlementInput(sgqlc.types.Input): + """Autogenerated input type of RemoveEnterpriseSupportEntitlement""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "login", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the Enterprise which the admin belongs to.""" + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of a member who will lose the support entitlement.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveLabelsFromLabelableInput(sgqlc.types.Input): + """Autogenerated input type of RemoveLabelsFromLabelable""" + + __schema__ = github_schema + __field_names__ = ("labelable_id", "label_ids", "client_mutation_id") + labelable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="labelableId") + """The id of the Labelable to remove labels from.""" + + label_ids = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="labelIds") + """The ids of labels to remove.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveOutsideCollaboratorInput(sgqlc.types.Input): + """Autogenerated input type of RemoveOutsideCollaborator""" + + __schema__ = github_schema + __field_names__ = ("user_id", "organization_id", "client_mutation_id") + user_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="userId") + """The ID of the outside collaborator to remove.""" + + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """The ID of the organization to remove the outside collaborator + from. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveReactionInput(sgqlc.types.Input): + """Autogenerated input type of RemoveReaction""" + + __schema__ = github_schema + __field_names__ = ("subject_id", "content", "client_mutation_id") + subject_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subjectId") + """The Node ID of the subject to modify.""" + + content = sgqlc.types.Field(sgqlc.types.non_null(ReactionContent), graphql_name="content") + """The name of the emoji reaction to remove.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveStarInput(sgqlc.types.Input): + """Autogenerated input type of RemoveStar""" + + __schema__ = github_schema + __field_names__ = ("starrable_id", "client_mutation_id") + starrable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="starrableId") + """The Starrable ID to unstar.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveUpvoteInput(sgqlc.types.Input): + """Autogenerated input type of RemoveUpvote""" + + __schema__ = github_schema + __field_names__ = ("subject_id", "client_mutation_id") + subject_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subjectId") + """The Node ID of the discussion or comment to remove upvote.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ReopenIssueInput(sgqlc.types.Input): + """Autogenerated input type of ReopenIssue""" + + __schema__ = github_schema + __field_names__ = ("issue_id", "client_mutation_id") + issue_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="issueId") + """ID of the issue to be opened.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ReopenPullRequestInput(sgqlc.types.Input): + """Autogenerated input type of ReopenPullRequest""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """ID of the pull request to be reopened.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RepositoryInvitationOrder(sgqlc.types.Input): + """Ordering options for repository invitation connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(RepositoryInvitationOrderField), graphql_name="field") + """The field to order repository invitations by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class RepositoryMigrationOrder(sgqlc.types.Input): + """Ordering options for repository migrations.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(RepositoryMigrationOrderField), graphql_name="field") + """The field to order repository migrations by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(RepositoryMigrationOrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class RepositoryOrder(sgqlc.types.Input): + """Ordering options for repository connections""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(RepositoryOrderField), graphql_name="field") + """The field to order repositories by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class RequestReviewsInput(sgqlc.types.Input): + """Autogenerated input type of RequestReviews""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "user_ids", "team_ids", "union", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """The Node ID of the pull request to modify.""" + + user_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="userIds") + """The Node IDs of the user to request.""" + + team_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="teamIds") + """The Node IDs of the team to request.""" + + union = sgqlc.types.Field(Boolean, graphql_name="union") + """Add users to the set rather than replace.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RequiredStatusCheckInput(sgqlc.types.Input): + """Specifies the attributes for a new or updated required status + check. + """ + + __schema__ = github_schema + __field_names__ = ("context", "app_id") + context = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="context") + """Status check context that must pass for commits to be accepted to + the matching branch. + """ + + app_id = sgqlc.types.Field(ID, graphql_name="appId") + """The ID of the App that must set the status in order for it to be + accepted. Omit this value to use whichever app has recently been + setting this status, or use "any" to allow any app to set the + status. + """ + + +class RerequestCheckSuiteInput(sgqlc.types.Input): + """Autogenerated input type of RerequestCheckSuite""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "check_suite_id", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + check_suite_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="checkSuiteId") + """The Node ID of the check suite.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ResolveReviewThreadInput(sgqlc.types.Input): + """Autogenerated input type of ResolveReviewThread""" + + __schema__ = github_schema + __field_names__ = ("thread_id", "client_mutation_id") + thread_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="threadId") + """The ID of the thread to resolve""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RevokeEnterpriseOrganizationsMigratorRoleInput(sgqlc.types.Input): + """Autogenerated input type of + RevokeEnterpriseOrganizationsMigratorRole + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "login", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise to which all organizations managed by it + will be granted the migrator role. + """ + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of the user to revoke the migrator role""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RevokeMigratorRoleInput(sgqlc.types.Input): + """Autogenerated input type of RevokeMigratorRole""" + + __schema__ = github_schema + __field_names__ = ("organization_id", "actor", "actor_type", "client_mutation_id") + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """The ID of the organization that the user/team belongs to.""" + + actor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="actor") + """The user login or Team slug to revoke the migrator role from.""" + + actor_type = sgqlc.types.Field(sgqlc.types.non_null(ActorType), graphql_name="actorType") + """Specifies the type of the actor, can be either USER or TEAM.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class SavedReplyOrder(sgqlc.types.Input): + """Ordering options for saved reply connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SavedReplyOrderField), graphql_name="field") + """The field to order saved replies by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SecurityAdvisoryIdentifierFilter(sgqlc.types.Input): + """An advisory identifier to filter results on.""" + + __schema__ = github_schema + __field_names__ = ("type", "value") + type = sgqlc.types.Field(sgqlc.types.non_null(SecurityAdvisoryIdentifierType), graphql_name="type") + """The identifier type.""" + + value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value") + """The identifier string. Supports exact or partial matching.""" + + +class SecurityAdvisoryOrder(sgqlc.types.Input): + """Ordering options for security advisory connections""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SecurityAdvisoryOrderField), graphql_name="field") + """The field to order security advisories by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SecurityVulnerabilityOrder(sgqlc.types.Input): + """Ordering options for security vulnerability connections""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SecurityVulnerabilityOrderField), graphql_name="field") + """The field to order security vulnerabilities by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SetEnterpriseIdentityProviderInput(sgqlc.types.Input): + """Autogenerated input type of SetEnterpriseIdentityProvider""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "sso_url", "issuer", "idp_certificate", "signature_method", "digest_method", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set an identity provider.""" + + sso_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="ssoUrl") + """The URL endpoint for the identity provider's SAML SSO.""" + + issuer = sgqlc.types.Field(String, graphql_name="issuer") + """The Issuer Entity ID for the SAML identity provider""" + + idp_certificate = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="idpCertificate") + """The x509 certificate used by the identity provider to sign + assertions and responses. + """ + + signature_method = sgqlc.types.Field(sgqlc.types.non_null(SamlSignatureAlgorithm), graphql_name="signatureMethod") + """The signature algorithm used to sign SAML requests for the + identity provider. + """ + + digest_method = sgqlc.types.Field(sgqlc.types.non_null(SamlDigestAlgorithm), graphql_name="digestMethod") + """The digest algorithm used to sign SAML requests for the identity + provider. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class SetOrganizationInteractionLimitInput(sgqlc.types.Input): + """Autogenerated input type of SetOrganizationInteractionLimit""" + + __schema__ = github_schema + __field_names__ = ("organization_id", "limit", "expiry", "client_mutation_id") + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """The ID of the organization to set a limit for.""" + + limit = sgqlc.types.Field(sgqlc.types.non_null(RepositoryInteractionLimit), graphql_name="limit") + """The limit to set.""" + + expiry = sgqlc.types.Field(RepositoryInteractionLimitExpiry, graphql_name="expiry") + """When this limit should expire.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class SetRepositoryInteractionLimitInput(sgqlc.types.Input): + """Autogenerated input type of SetRepositoryInteractionLimit""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "limit", "expiry", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The ID of the repository to set a limit for.""" + + limit = sgqlc.types.Field(sgqlc.types.non_null(RepositoryInteractionLimit), graphql_name="limit") + """The limit to set.""" + + expiry = sgqlc.types.Field(RepositoryInteractionLimitExpiry, graphql_name="expiry") + """When this limit should expire.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class SetUserInteractionLimitInput(sgqlc.types.Input): + """Autogenerated input type of SetUserInteractionLimit""" + + __schema__ = github_schema + __field_names__ = ("user_id", "limit", "expiry", "client_mutation_id") + user_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="userId") + """The ID of the user to set a limit for.""" + + limit = sgqlc.types.Field(sgqlc.types.non_null(RepositoryInteractionLimit), graphql_name="limit") + """The limit to set.""" + + expiry = sgqlc.types.Field(RepositoryInteractionLimitExpiry, graphql_name="expiry") + """When this limit should expire.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class SponsorOrder(sgqlc.types.Input): + """Ordering options for connections to get sponsor entities for + GitHub Sponsors. + """ + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SponsorOrderField), graphql_name="field") + """The field to order sponsor entities by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SponsorableOrder(sgqlc.types.Input): + """Ordering options for connections to get sponsorable entities for + GitHub Sponsors. + """ + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SponsorableOrderField), graphql_name="field") + """The field to order sponsorable entities by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SponsorsActivityOrder(sgqlc.types.Input): + """Ordering options for GitHub Sponsors activity connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SponsorsActivityOrderField), graphql_name="field") + """The field to order activity by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SponsorsTierOrder(sgqlc.types.Input): + """Ordering options for Sponsors tiers connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SponsorsTierOrderField), graphql_name="field") + """The field to order tiers by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SponsorshipNewsletterOrder(sgqlc.types.Input): + """Ordering options for sponsorship newsletter connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SponsorshipNewsletterOrderField), graphql_name="field") + """The field to order sponsorship newsletters by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class SponsorshipOrder(sgqlc.types.Input): + """Ordering options for sponsorship connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(SponsorshipOrderField), graphql_name="field") + """The field to order sponsorship by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class StarOrder(sgqlc.types.Input): + """Ways in which star connections can be ordered.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(StarOrderField), graphql_name="field") + """The field in which to order nodes by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order nodes.""" + + +class StartRepositoryMigrationInput(sgqlc.types.Input): + """Autogenerated input type of StartRepositoryMigration""" + + __schema__ = github_schema + __field_names__ = ( + "source_id", + "owner_id", + "source_repository_url", + "repository_name", + "continue_on_error", + "git_archive_url", + "metadata_archive_url", + "access_token", + "github_pat", + "skip_releases", + "client_mutation_id", + ) + source_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="sourceId") + """The ID of the Octoshift migration source.""" + + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the organization that will own the imported repository.""" + + source_repository_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="sourceRepositoryUrl") + """The Octoshift migration source repository URL.""" + + repository_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="repositoryName") + """The name of the imported repository.""" + + continue_on_error = sgqlc.types.Field(Boolean, graphql_name="continueOnError") + """Whether to continue the migration on error""" + + git_archive_url = sgqlc.types.Field(String, graphql_name="gitArchiveUrl") + """The signed URL to access the user-uploaded git archive""" + + metadata_archive_url = sgqlc.types.Field(String, graphql_name="metadataArchiveUrl") + """The signed URL to access the user-uploaded metadata archive""" + + access_token = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="accessToken") + """The Octoshift migration source access token.""" + + github_pat = sgqlc.types.Field(String, graphql_name="githubPat") + """The GitHub personal access token of the user importing to the + target repository. + """ + + skip_releases = sgqlc.types.Field(Boolean, graphql_name="skipReleases") + """Whether to skip migrating releases for the repository.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class SubmitPullRequestReviewInput(sgqlc.types.Input): + """Autogenerated input type of SubmitPullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "pull_request_review_id", "event", "body", "client_mutation_id") + pull_request_id = sgqlc.types.Field(ID, graphql_name="pullRequestId") + """The Pull Request ID to submit any pending reviews.""" + + pull_request_review_id = sgqlc.types.Field(ID, graphql_name="pullRequestReviewId") + """The Pull Request Review ID to submit.""" + + event = sgqlc.types.Field(sgqlc.types.non_null(PullRequestReviewEvent), graphql_name="event") + """The event to send to the Pull Request Review.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The text field to set on the Pull Request Review.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class TeamDiscussionCommentOrder(sgqlc.types.Input): + """Ways in which team discussion comment connections can be ordered.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(TeamDiscussionCommentOrderField), graphql_name="field") + """The field by which to order nodes.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order nodes.""" + + +class TeamDiscussionOrder(sgqlc.types.Input): + """Ways in which team discussion connections can be ordered.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(TeamDiscussionOrderField), graphql_name="field") + """The field by which to order nodes.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order nodes.""" + + +class TeamMemberOrder(sgqlc.types.Input): + """Ordering options for team member connections""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(TeamMemberOrderField), graphql_name="field") + """The field to order team members by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class TeamOrder(sgqlc.types.Input): + """Ways in which team connections can be ordered.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(TeamOrderField), graphql_name="field") + """The field in which to order nodes by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction in which to order nodes.""" + + +class TeamRepositoryOrder(sgqlc.types.Input): + """Ordering options for team repository connections""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(TeamRepositoryOrderField), graphql_name="field") + """The field to order repositories by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class TransferIssueInput(sgqlc.types.Input): + """Autogenerated input type of TransferIssue""" + + __schema__ = github_schema + __field_names__ = ("issue_id", "repository_id", "client_mutation_id") + issue_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="issueId") + """The Node ID of the issue to be transferred""" + + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository the issue should be transferred to""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnarchiveRepositoryInput(sgqlc.types.Input): + """Autogenerated input type of UnarchiveRepository""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The ID of the repository to unarchive.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnfollowOrganizationInput(sgqlc.types.Input): + """Autogenerated input type of UnfollowOrganization""" + + __schema__ = github_schema + __field_names__ = ("organization_id", "client_mutation_id") + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """ID of the organization to unfollow.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnfollowUserInput(sgqlc.types.Input): + """Autogenerated input type of UnfollowUser""" + + __schema__ = github_schema + __field_names__ = ("user_id", "client_mutation_id") + user_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="userId") + """ID of the user to unfollow.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnlinkRepositoryFromProjectInput(sgqlc.types.Input): + """Autogenerated input type of UnlinkRepositoryFromProject""" + + __schema__ = github_schema + __field_names__ = ("project_id", "repository_id", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The ID of the Project linked to the Repository.""" + + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The ID of the Repository linked to the Project.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnlockLockableInput(sgqlc.types.Input): + """Autogenerated input type of UnlockLockable""" + + __schema__ = github_schema + __field_names__ = ("lockable_id", "client_mutation_id") + lockable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="lockableId") + """ID of the item to be unlocked.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnmarkDiscussionCommentAsAnswerInput(sgqlc.types.Input): + """Autogenerated input type of UnmarkDiscussionCommentAsAnswer""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The Node ID of the discussion comment to unmark as an answer.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnmarkFileAsViewedInput(sgqlc.types.Input): + """Autogenerated input type of UnmarkFileAsViewed""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "path", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """The Node ID of the pull request.""" + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path of the file to mark as unviewed""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnmarkIssueAsDuplicateInput(sgqlc.types.Input): + """Autogenerated input type of UnmarkIssueAsDuplicate""" + + __schema__ = github_schema + __field_names__ = ("duplicate_id", "canonical_id", "client_mutation_id") + duplicate_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="duplicateId") + """ID of the issue or pull request currently marked as a duplicate.""" + + canonical_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="canonicalId") + """ID of the issue or pull request currently considered + canonical/authoritative/original. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnminimizeCommentInput(sgqlc.types.Input): + """Autogenerated input type of UnminimizeComment""" + + __schema__ = github_schema + __field_names__ = ("subject_id", "client_mutation_id") + subject_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subjectId") + """The Node ID of the subject to modify.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnpinIssueInput(sgqlc.types.Input): + """Autogenerated input type of UnpinIssue""" + + __schema__ = github_schema + __field_names__ = ("issue_id", "client_mutation_id") + issue_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="issueId") + """The ID of the issue to be unpinned""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UnresolveReviewThreadInput(sgqlc.types.Input): + """Autogenerated input type of UnresolveReviewThread""" + + __schema__ = github_schema + __field_names__ = ("thread_id", "client_mutation_id") + thread_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="threadId") + """The ID of the thread to unresolve""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateBranchProtectionRuleInput(sgqlc.types.Input): + """Autogenerated input type of UpdateBranchProtectionRule""" + + __schema__ = github_schema + __field_names__ = ( + "branch_protection_rule_id", + "pattern", + "requires_approving_reviews", + "required_approving_review_count", + "requires_commit_signatures", + "requires_linear_history", + "blocks_creations", + "allows_force_pushes", + "allows_deletions", + "is_admin_enforced", + "requires_status_checks", + "requires_strict_status_checks", + "requires_code_owner_reviews", + "dismisses_stale_reviews", + "restricts_review_dismissals", + "review_dismissal_actor_ids", + "bypass_pull_request_actor_ids", + "bypass_force_push_actor_ids", + "restricts_pushes", + "push_actor_ids", + "required_status_check_contexts", + "required_status_checks", + "requires_conversation_resolution", + "client_mutation_id", + ) + branch_protection_rule_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="branchProtectionRuleId") + """The global relay id of the branch protection rule to be updated.""" + + pattern = sgqlc.types.Field(String, graphql_name="pattern") + """The glob-like pattern used to determine matching branches.""" + + requires_approving_reviews = sgqlc.types.Field(Boolean, graphql_name="requiresApprovingReviews") + """Are approving reviews required to update matching branches.""" + + required_approving_review_count = sgqlc.types.Field(Int, graphql_name="requiredApprovingReviewCount") + """Number of approving reviews required to update matching branches.""" + + requires_commit_signatures = sgqlc.types.Field(Boolean, graphql_name="requiresCommitSignatures") + """Are commits required to be signed.""" + + requires_linear_history = sgqlc.types.Field(Boolean, graphql_name="requiresLinearHistory") + """Are merge commits prohibited from being pushed to this branch.""" + + blocks_creations = sgqlc.types.Field(Boolean, graphql_name="blocksCreations") + """Is branch creation a protected operation.""" + + allows_force_pushes = sgqlc.types.Field(Boolean, graphql_name="allowsForcePushes") + """Are force pushes allowed on this branch.""" + + allows_deletions = sgqlc.types.Field(Boolean, graphql_name="allowsDeletions") + """Can this branch be deleted.""" + + is_admin_enforced = sgqlc.types.Field(Boolean, graphql_name="isAdminEnforced") + """Can admins overwrite branch protection.""" + + requires_status_checks = sgqlc.types.Field(Boolean, graphql_name="requiresStatusChecks") + """Are status checks required to update matching branches.""" + + requires_strict_status_checks = sgqlc.types.Field(Boolean, graphql_name="requiresStrictStatusChecks") + """Are branches required to be up to date before merging.""" + + requires_code_owner_reviews = sgqlc.types.Field(Boolean, graphql_name="requiresCodeOwnerReviews") + """Are reviews from code owners required to update matching branches.""" + + dismisses_stale_reviews = sgqlc.types.Field(Boolean, graphql_name="dismissesStaleReviews") + """Will new commits pushed to matching branches dismiss pull request + review approvals. + """ + + restricts_review_dismissals = sgqlc.types.Field(Boolean, graphql_name="restrictsReviewDismissals") + """Is dismissal of pull request reviews restricted.""" + + review_dismissal_actor_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="reviewDismissalActorIds") + """A list of User, Team, or App IDs allowed to dismiss reviews on + pull requests targeting matching branches. + """ + + bypass_pull_request_actor_ids = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="bypassPullRequestActorIds" + ) + """A list of User, Team, or App IDs allowed to bypass pull requests + targeting matching branches. + """ + + bypass_force_push_actor_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="bypassForcePushActorIds") + """A list of User, Team, or App IDs allowed to bypass force push + targeting matching branches. + """ + + restricts_pushes = sgqlc.types.Field(Boolean, graphql_name="restrictsPushes") + """Is pushing to matching branches restricted.""" + + push_actor_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="pushActorIds") + """A list of User, Team, or App IDs allowed to push to matching + branches. + """ + + required_status_check_contexts = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="requiredStatusCheckContexts" + ) + """List of required status check contexts that must pass for commits + to be accepted to matching branches. + """ + + required_status_checks = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(RequiredStatusCheckInput)), graphql_name="requiredStatusChecks" + ) + """The list of required status checks""" + + requires_conversation_resolution = sgqlc.types.Field(Boolean, graphql_name="requiresConversationResolution") + """Are conversations required to be resolved before merging.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateCheckRunInput(sgqlc.types.Input): + """Autogenerated input type of UpdateCheckRun""" + + __schema__ = github_schema + __field_names__ = ( + "repository_id", + "check_run_id", + "name", + "details_url", + "external_id", + "status", + "started_at", + "conclusion", + "completed_at", + "output", + "actions", + "client_mutation_id", + ) + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The node ID of the repository.""" + + check_run_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="checkRunId") + """The node of the check.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the check.""" + + details_url = sgqlc.types.Field(URI, graphql_name="detailsUrl") + """The URL of the integrator's site that has the full details of the + check. + """ + + external_id = sgqlc.types.Field(String, graphql_name="externalId") + """A reference for the run on the integrator's system.""" + + status = sgqlc.types.Field(RequestableCheckStatusState, graphql_name="status") + """The current status.""" + + started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt") + """The time that the check run began.""" + + conclusion = sgqlc.types.Field(CheckConclusionState, graphql_name="conclusion") + """The final conclusion of the check.""" + + completed_at = sgqlc.types.Field(DateTime, graphql_name="completedAt") + """The time that the check run finished.""" + + output = sgqlc.types.Field(CheckRunOutput, graphql_name="output") + """Descriptive details about the run.""" + + actions = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(CheckRunAction)), graphql_name="actions") + """Possible further actions the integrator can perform, which a user + may trigger. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateCheckSuitePreferencesInput(sgqlc.types.Input): + """Autogenerated input type of UpdateCheckSuitePreferences""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "auto_trigger_preferences", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + auto_trigger_preferences = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(CheckSuiteAutoTriggerPreference))), + graphql_name="autoTriggerPreferences", + ) + """The check suite preferences to modify.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateDiscussionCommentInput(sgqlc.types.Input): + """Autogenerated input type of UpdateDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("comment_id", "body", "client_mutation_id") + comment_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="commentId") + """The Node ID of the discussion comment to update.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The new contents of the comment body.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateDiscussionInput(sgqlc.types.Input): + """Autogenerated input type of UpdateDiscussion""" + + __schema__ = github_schema + __field_names__ = ("discussion_id", "title", "body", "category_id", "client_mutation_id") + discussion_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="discussionId") + """The Node ID of the discussion to update.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The new discussion title.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The new contents of the discussion body.""" + + category_id = sgqlc.types.Field(ID, graphql_name="categoryId") + """The Node ID of a discussion category within the same repository to + change this discussion to. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseAdministratorRoleInput(sgqlc.types.Input): + """Autogenerated input type of UpdateEnterpriseAdministratorRole""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "login", "role", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the Enterprise which the admin belongs to.""" + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of a administrator whose role is being changed.""" + + role = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseAdministratorRole), graphql_name="role") + """The new role for the Enterprise administrator.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseAllowPrivateRepositoryForkingSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseAllowPrivateRepositoryForkingSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the allow private + repository forking setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the allow private repository forking setting on the + enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseDefaultRepositoryPermissionSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseDefaultRepositoryPermissionSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the base repository + permission setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseDefaultRepositoryPermissionSettingValue), graphql_name="settingValue") + """The value for the base repository permission setting on the + enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanChangeRepositoryVisibilitySetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can change + repository visibility setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the members can change repository visibility setting + on the enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanCreateRepositoriesSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanCreateRepositoriesSetting + """ + + __schema__ = github_schema + __field_names__ = ( + "enterprise_id", + "setting_value", + "members_can_create_repositories_policy_enabled", + "members_can_create_public_repositories", + "members_can_create_private_repositories", + "members_can_create_internal_repositories", + "client_mutation_id", + ) + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can create + repositories setting. + """ + + setting_value = sgqlc.types.Field(EnterpriseMembersCanCreateRepositoriesSettingValue, graphql_name="settingValue") + """Value for the members can create repositories setting on the + enterprise. This or the granular public/private/internal allowed + fields (but not both) must be provided. + """ + + members_can_create_repositories_policy_enabled = sgqlc.types.Field(Boolean, graphql_name="membersCanCreateRepositoriesPolicyEnabled") + """When false, allow member organizations to set their own repository + creation member privileges. + """ + + members_can_create_public_repositories = sgqlc.types.Field(Boolean, graphql_name="membersCanCreatePublicRepositories") + """Allow members to create public repositories. Defaults to current + value. + """ + + members_can_create_private_repositories = sgqlc.types.Field(Boolean, graphql_name="membersCanCreatePrivateRepositories") + """Allow members to create private repositories. Defaults to current + value. + """ + + members_can_create_internal_repositories = sgqlc.types.Field(Boolean, graphql_name="membersCanCreateInternalRepositories") + """Allow members to create internal repositories. Defaults to current + value. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanDeleteIssuesSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanDeleteIssuesSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can delete + issues setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the members can delete issues setting on the + enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanDeleteRepositoriesSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanDeleteRepositoriesSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can delete + repositories setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the members can delete repositories setting on the + enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanInviteCollaboratorsSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanInviteCollaboratorsSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can invite + collaborators setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the members can invite collaborators setting on the + enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanMakePurchasesSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanMakePurchasesSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can make + purchases setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseMembersCanMakePurchasesSettingValue), graphql_name="settingValue") + """The value for the members can make purchases setting on the + enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanUpdateProtectedBranchesSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can update + protected branches setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the members can update protected branches setting on + the enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseMembersCanViewDependencyInsightsSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseMembersCanViewDependencyInsightsSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the members can view + dependency insights setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the members can view dependency insights setting on + the enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseOrganizationProjectsSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseOrganizationProjectsSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the organization projects + setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the organization projects setting on the enterprise.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseOwnerOrganizationRoleInput(sgqlc.types.Input): + """Autogenerated input type of UpdateEnterpriseOwnerOrganizationRole""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "organization_id", "organization_role", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the Enterprise which the owner belongs to.""" + + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """The ID of the organization for membership change.""" + + organization_role = sgqlc.types.Field(sgqlc.types.non_null(RoleInOrganization), graphql_name="organizationRole") + """The role to assume in the organization.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseProfileInput(sgqlc.types.Input): + """Autogenerated input type of UpdateEnterpriseProfile""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "name", "description", "website_url", "location", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The Enterprise ID to update.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the enterprise.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The description of the enterprise.""" + + website_url = sgqlc.types.Field(String, graphql_name="websiteUrl") + """The URL of the enterprise's website.""" + + location = sgqlc.types.Field(String, graphql_name="location") + """The location of the enterprise.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseRepositoryProjectsSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseRepositoryProjectsSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the repository projects + setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the repository projects setting on the enterprise.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseTeamDiscussionsSettingInput(sgqlc.types.Input): + """Autogenerated input type of UpdateEnterpriseTeamDiscussionsSetting""" + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the team discussions + setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="settingValue") + """The value for the team discussions setting on the enterprise.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateEnterpriseTwoFactorAuthenticationRequiredSetting + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_id", "setting_value", "client_mutation_id") + enterprise_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="enterpriseId") + """The ID of the enterprise on which to set the two factor + authentication required setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseEnabledSettingValue), graphql_name="settingValue") + """The value for the two factor authentication required setting on + the enterprise. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateEnvironmentInput(sgqlc.types.Input): + """Autogenerated input type of UpdateEnvironment""" + + __schema__ = github_schema + __field_names__ = ("environment_id", "wait_timer", "reviewers", "client_mutation_id") + environment_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="environmentId") + """The node ID of the environment.""" + + wait_timer = sgqlc.types.Field(Int, graphql_name="waitTimer") + """The wait timer in minutes.""" + + reviewers = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="reviewers") + """The ids of users or teams that can approve deployments to this + environment + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateIpAllowListEnabledSettingInput(sgqlc.types.Input): + """Autogenerated input type of UpdateIpAllowListEnabledSetting""" + + __schema__ = github_schema + __field_names__ = ("owner_id", "setting_value", "client_mutation_id") + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the owner on which to set the IP allow list enabled + setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(IpAllowListEnabledSettingValue), graphql_name="settingValue") + """The value for the IP allow list enabled setting.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateIpAllowListEntryInput(sgqlc.types.Input): + """Autogenerated input type of UpdateIpAllowListEntry""" + + __schema__ = github_schema + __field_names__ = ("ip_allow_list_entry_id", "allow_list_value", "name", "is_active", "client_mutation_id") + ip_allow_list_entry_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ipAllowListEntryId") + """The ID of the IP allow list entry to update.""" + + allow_list_value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="allowListValue") + """An IP address or range of addresses in CIDR notation.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """An optional name for the IP allow list entry.""" + + is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive") + """Whether the IP allow list entry is active when an IP allow list is + enabled. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateIpAllowListForInstalledAppsEnabledSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateIpAllowListForInstalledAppsEnabledSetting + """ + + __schema__ = github_schema + __field_names__ = ("owner_id", "setting_value", "client_mutation_id") + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the owner.""" + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(IpAllowListForInstalledAppsEnabledSettingValue), graphql_name="settingValue") + """The value for the IP allow list configuration for installed GitHub + Apps setting. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateIssueCommentInput(sgqlc.types.Input): + """Autogenerated input type of UpdateIssueComment""" + + __schema__ = github_schema + __field_names__ = ("id", "body", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the IssueComment to modify.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The updated text of the comment.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateIssueInput(sgqlc.types.Input): + """Autogenerated input type of UpdateIssue""" + + __schema__ = github_schema + __field_names__ = ("id", "title", "body", "assignee_ids", "milestone_id", "label_ids", "state", "project_ids", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the Issue to modify.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The title for the issue.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The body for the issue description.""" + + assignee_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="assigneeIds") + """An array of Node IDs of users for this issue.""" + + milestone_id = sgqlc.types.Field(ID, graphql_name="milestoneId") + """The Node ID of the milestone for this issue.""" + + label_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="labelIds") + """An array of Node IDs of labels for this issue.""" + + state = sgqlc.types.Field(IssueState, graphql_name="state") + """The desired issue state.""" + + project_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="projectIds") + """An array of Node IDs for projects associated with this issue.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateNotificationRestrictionSettingInput(sgqlc.types.Input): + """Autogenerated input type of UpdateNotificationRestrictionSetting""" + + __schema__ = github_schema + __field_names__ = ("owner_id", "setting_value", "client_mutation_id") + owner_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="ownerId") + """The ID of the owner on which to set the restrict notifications + setting. + """ + + setting_value = sgqlc.types.Field(sgqlc.types.non_null(NotificationRestrictionSettingValue), graphql_name="settingValue") + """The value for the restrict notifications setting.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateOrganizationAllowPrivateRepositoryForkingSettingInput(sgqlc.types.Input): + """Autogenerated input type of + UpdateOrganizationAllowPrivateRepositoryForkingSetting + """ + + __schema__ = github_schema + __field_names__ = ("organization_id", "forking_enabled", "client_mutation_id") + organization_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="organizationId") + """The ID of the organization on which to set the allow private + repository forking setting. + """ + + forking_enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="forkingEnabled") + """Enable forking of private repositories in the organization?""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateProjectCardInput(sgqlc.types.Input): + """Autogenerated input type of UpdateProjectCard""" + + __schema__ = github_schema + __field_names__ = ("project_card_id", "is_archived", "note", "client_mutation_id") + project_card_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectCardId") + """The ProjectCard ID to update.""" + + is_archived = sgqlc.types.Field(Boolean, graphql_name="isArchived") + """Whether or not the ProjectCard should be archived""" + + note = sgqlc.types.Field(String, graphql_name="note") + """The note of ProjectCard.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateProjectColumnInput(sgqlc.types.Input): + """Autogenerated input type of UpdateProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("project_column_id", "name", "client_mutation_id") + project_column_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectColumnId") + """The ProjectColumn ID to update.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of project column.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateProjectDraftIssueInput(sgqlc.types.Input): + """Autogenerated input type of UpdateProjectDraftIssue""" + + __schema__ = github_schema + __field_names__ = ("draft_issue_id", "title", "body", "assignee_ids", "client_mutation_id") + draft_issue_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="draftIssueId") + """The ID of the draft issue to update.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The title of the draft issue.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The body of the draft issue.""" + + assignee_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="assigneeIds") + """The IDs of the assignees of the draft issue.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateProjectInput(sgqlc.types.Input): + """Autogenerated input type of UpdateProject""" + + __schema__ = github_schema + __field_names__ = ("project_id", "name", "body", "state", "public", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The Project ID to update.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of project.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The description of project.""" + + state = sgqlc.types.Field(ProjectState, graphql_name="state") + """Whether the project is open or closed.""" + + public = sgqlc.types.Field(Boolean, graphql_name="public") + """Whether the project is public or not.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateProjectNextInput(sgqlc.types.Input): + """Autogenerated input type of UpdateProjectNext""" + + __schema__ = github_schema + __field_names__ = ("project_id", "title", "description", "short_description", "closed", "public", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The ID of the Project to update.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """Set the title of the project.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """Set the readme description of the project.""" + + short_description = sgqlc.types.Field(String, graphql_name="shortDescription") + """Set the short description of the project.""" + + closed = sgqlc.types.Field(Boolean, graphql_name="closed") + """Set the project to closed or open.""" + + public = sgqlc.types.Field(Boolean, graphql_name="public") + """Set the project to public or private.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateProjectNextItemFieldInput(sgqlc.types.Input): + """Autogenerated input type of UpdateProjectNextItemField""" + + __schema__ = github_schema + __field_names__ = ("project_id", "item_id", "field_id", "value", "client_mutation_id") + project_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="projectId") + """The ID of the Project.""" + + item_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="itemId") + """The id of the item to be updated.""" + + field_id = sgqlc.types.Field(ID, graphql_name="fieldId") + """The id of the field to be updated.""" + + value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value") + """The value which will be set on the field.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdatePullRequestBranchInput(sgqlc.types.Input): + """Autogenerated input type of UpdatePullRequestBranch""" + + __schema__ = github_schema + __field_names__ = ("pull_request_id", "expected_head_oid", "client_mutation_id") + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """The Node ID of the pull request.""" + + expected_head_oid = sgqlc.types.Field(GitObjectID, graphql_name="expectedHeadOid") + """The head ref oid for the upstream branch.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdatePullRequestInput(sgqlc.types.Input): + """Autogenerated input type of UpdatePullRequest""" + + __schema__ = github_schema + __field_names__ = ( + "pull_request_id", + "base_ref_name", + "title", + "body", + "state", + "maintainer_can_modify", + "assignee_ids", + "milestone_id", + "label_ids", + "project_ids", + "client_mutation_id", + ) + pull_request_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestId") + """The Node ID of the pull request.""" + + base_ref_name = sgqlc.types.Field(String, graphql_name="baseRefName") + """The name of the branch you want your changes pulled into. This + should be an existing branch on the current repository. + """ + + title = sgqlc.types.Field(String, graphql_name="title") + """The title of the pull request.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The contents of the pull request.""" + + state = sgqlc.types.Field(PullRequestUpdateState, graphql_name="state") + """The target state of the pull request.""" + + maintainer_can_modify = sgqlc.types.Field(Boolean, graphql_name="maintainerCanModify") + """Indicates whether maintainers can modify the pull request.""" + + assignee_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="assigneeIds") + """An array of Node IDs of users for this pull request.""" + + milestone_id = sgqlc.types.Field(ID, graphql_name="milestoneId") + """The Node ID of the milestone for this pull request.""" + + label_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="labelIds") + """An array of Node IDs of labels for this pull request.""" + + project_ids = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(ID)), graphql_name="projectIds") + """An array of Node IDs for projects associated with this pull + request. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdatePullRequestReviewCommentInput(sgqlc.types.Input): + """Autogenerated input type of UpdatePullRequestReviewComment""" + + __schema__ = github_schema + __field_names__ = ("pull_request_review_comment_id", "body", "client_mutation_id") + pull_request_review_comment_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestReviewCommentId") + """The Node ID of the comment to modify.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The text of the comment.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdatePullRequestReviewInput(sgqlc.types.Input): + """Autogenerated input type of UpdatePullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("pull_request_review_id", "body", "client_mutation_id") + pull_request_review_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="pullRequestReviewId") + """The Node ID of the pull request review to modify.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The contents of the pull request review body.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateRefInput(sgqlc.types.Input): + """Autogenerated input type of UpdateRef""" + + __schema__ = github_schema + __field_names__ = ("ref_id", "oid", "force", "client_mutation_id") + ref_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="refId") + """The Node ID of the Ref to be updated.""" + + oid = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="oid") + """The GitObjectID that the Ref shall be updated to target.""" + + force = sgqlc.types.Field(Boolean, graphql_name="force") + """Permit updates of branch Refs that are not fast-forwards?""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateRepositoryInput(sgqlc.types.Input): + """Autogenerated input type of UpdateRepository""" + + __schema__ = github_schema + __field_names__ = ( + "repository_id", + "name", + "description", + "template", + "homepage_url", + "has_wiki_enabled", + "has_issues_enabled", + "has_projects_enabled", + "client_mutation_id", + ) + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The ID of the repository to update.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The new name of the repository.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """A new description for the repository. Pass an empty string to + erase the existing description. + """ + + template = sgqlc.types.Field(Boolean, graphql_name="template") + """Whether this repository should be marked as a template such that + anyone who can access it can create new repositories with the same + files and directory structure. + """ + + homepage_url = sgqlc.types.Field(URI, graphql_name="homepageUrl") + """The URL for a web page about this repository. Pass an empty string + to erase the existing URL. + """ + + has_wiki_enabled = sgqlc.types.Field(Boolean, graphql_name="hasWikiEnabled") + """Indicates if the repository should have the wiki feature enabled.""" + + has_issues_enabled = sgqlc.types.Field(Boolean, graphql_name="hasIssuesEnabled") + """Indicates if the repository should have the issues feature + enabled. + """ + + has_projects_enabled = sgqlc.types.Field(Boolean, graphql_name="hasProjectsEnabled") + """Indicates if the repository should have the project boards feature + enabled. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateSponsorshipPreferencesInput(sgqlc.types.Input): + """Autogenerated input type of UpdateSponsorshipPreferences""" + + __schema__ = github_schema + __field_names__ = ( + "sponsor_id", + "sponsor_login", + "sponsorable_id", + "sponsorable_login", + "receive_emails", + "privacy_level", + "client_mutation_id", + ) + sponsor_id = sgqlc.types.Field(ID, graphql_name="sponsorId") + """The ID of the user or organization who is acting as the sponsor, + paying for the sponsorship. Required if sponsorLogin is not given. + """ + + sponsor_login = sgqlc.types.Field(String, graphql_name="sponsorLogin") + """The username of the user or organization who is acting as the + sponsor, paying for the sponsorship. Required if sponsorId is not + given. + """ + + sponsorable_id = sgqlc.types.Field(ID, graphql_name="sponsorableId") + """The ID of the user or organization who is receiving the + sponsorship. Required if sponsorableLogin is not given. + """ + + sponsorable_login = sgqlc.types.Field(String, graphql_name="sponsorableLogin") + """The username of the user or organization who is receiving the + sponsorship. Required if sponsorableId is not given. + """ + + receive_emails = sgqlc.types.Field(Boolean, graphql_name="receiveEmails") + """Whether the sponsor should receive email updates from the + sponsorable. + """ + + privacy_level = sgqlc.types.Field(SponsorshipPrivacy, graphql_name="privacyLevel") + """Specify whether others should be able to see that the sponsor is + sponsoring the sponsorable. Public visibility still does not + reveal which tier is used. + """ + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateSubscriptionInput(sgqlc.types.Input): + """Autogenerated input type of UpdateSubscription""" + + __schema__ = github_schema + __field_names__ = ("subscribable_id", "state", "client_mutation_id") + subscribable_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="subscribableId") + """The Node ID of the subscribable object to modify.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(SubscriptionState), graphql_name="state") + """The new state of the subscription.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateTeamDiscussionCommentInput(sgqlc.types.Input): + """Autogenerated input type of UpdateTeamDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("id", "body", "body_version", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the comment to modify.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The updated text of the comment.""" + + body_version = sgqlc.types.Field(String, graphql_name="bodyVersion") + """The current version of the body content.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateTeamDiscussionInput(sgqlc.types.Input): + """Autogenerated input type of UpdateTeamDiscussion""" + + __schema__ = github_schema + __field_names__ = ("id", "title", "body", "body_version", "pinned", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The Node ID of the discussion to modify.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The updated title of the discussion.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The updated text of the discussion.""" + + body_version = sgqlc.types.Field(String, graphql_name="bodyVersion") + """The current version of the body content. If provided, this update + operation will be rejected if the given version does not match the + latest version on the server. + """ + + pinned = sgqlc.types.Field(Boolean, graphql_name="pinned") + """If provided, sets the pinned state of the updated discussion.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateTeamsRepositoryInput(sgqlc.types.Input): + """Autogenerated input type of UpdateTeamsRepository""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "team_ids", "permission", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """Repository ID being granted access to.""" + + team_ids = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="teamIds") + """A list of teams being granted access. Limit: 10""" + + permission = sgqlc.types.Field(sgqlc.types.non_null(RepositoryPermission), graphql_name="permission") + """Permission that should be granted to the teams.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateTopicsInput(sgqlc.types.Input): + """Autogenerated input type of UpdateTopics""" + + __schema__ = github_schema + __field_names__ = ("repository_id", "topic_names", "client_mutation_id") + repository_id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="repositoryId") + """The Node ID of the repository.""" + + topic_names = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))), graphql_name="topicNames") + """An array of topic names.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UserStatusOrder(sgqlc.types.Input): + """Ordering options for user status connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(UserStatusOrderField), graphql_name="field") + """The field to order user statuses by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class VerifiableDomainOrder(sgqlc.types.Input): + """Ordering options for verifiable domain connections.""" + + __schema__ = github_schema + __field_names__ = ("field", "direction") + field = sgqlc.types.Field(sgqlc.types.non_null(VerifiableDomainOrderField), graphql_name="field") + """The field to order verifiable domains by.""" + + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The ordering direction.""" + + +class VerifyVerifiableDomainInput(sgqlc.types.Input): + """Autogenerated input type of VerifyVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("id", "client_mutation_id") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """The ID of the verifiable domain to verify.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +######################################################################## +# Output Objects and Interfaces +######################################################################## +class AbortQueuedMigrationsPayload(sgqlc.types.Type): + """Autogenerated return type of AbortQueuedMigrations""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "success") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + success = sgqlc.types.Field(Boolean, graphql_name="success") + """Did the operation succeed?""" + + +class AcceptEnterpriseAdministratorInvitationPayload(sgqlc.types.Type): + """Autogenerated return type of + AcceptEnterpriseAdministratorInvitation + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "invitation", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + invitation = sgqlc.types.Field("EnterpriseAdministratorInvitation", graphql_name="invitation") + """The invitation that was accepted.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of accepting an administrator + invitation. + """ + + +class AcceptTopicSuggestionPayload(sgqlc.types.Type): + """Autogenerated return type of AcceptTopicSuggestion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "topic") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + topic = sgqlc.types.Field("Topic", graphql_name="topic") + """The accepted topic.""" + + +class Actor(sgqlc.types.Interface): + """Represents an object which can take actions on GitHub. Typically a + User or Bot. + """ + + __schema__ = github_schema + __field_names__ = ("avatar_url", "login", "resource_path", "url") + avatar_url = sgqlc.types.Field( + sgqlc.types.non_null(URI), + graphql_name="avatarUrl", + args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=None)),)), + ) + """A URL pointing to the actor's public avatar. + + Arguments: + + * `size` (`Int`): The size of the resulting square image. + """ + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The username of the actor.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this actor.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this actor.""" + + +class ActorLocation(sgqlc.types.Type): + """Location information for an actor""" + + __schema__ = github_schema + __field_names__ = ("city", "country", "country_code", "region", "region_code") + city = sgqlc.types.Field(String, graphql_name="city") + """City""" + + country = sgqlc.types.Field(String, graphql_name="country") + """Country name""" + + country_code = sgqlc.types.Field(String, graphql_name="countryCode") + """Country code""" + + region = sgqlc.types.Field(String, graphql_name="region") + """Region name""" + + region_code = sgqlc.types.Field(String, graphql_name="regionCode") + """Region or state code""" + + +class AddAssigneesToAssignablePayload(sgqlc.types.Type): + """Autogenerated return type of AddAssigneesToAssignable""" + + __schema__ = github_schema + __field_names__ = ("assignable", "client_mutation_id") + assignable = sgqlc.types.Field("Assignable", graphql_name="assignable") + """The item that was assigned.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class AddCommentPayload(sgqlc.types.Type): + """Autogenerated return type of AddComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "comment_edge", "subject", "timeline_edge") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + comment_edge = sgqlc.types.Field("IssueCommentEdge", graphql_name="commentEdge") + """The edge from the subject's comment connection.""" + + subject = sgqlc.types.Field("Node", graphql_name="subject") + """The subject""" + + timeline_edge = sgqlc.types.Field("IssueTimelineItemEdge", graphql_name="timelineEdge") + """The edge from the subject's timeline connection.""" + + +class AddDiscussionCommentPayload(sgqlc.types.Type): + """Autogenerated return type of AddDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + comment = sgqlc.types.Field("DiscussionComment", graphql_name="comment") + """The newly created discussion comment.""" + + +class AddDiscussionPollVotePayload(sgqlc.types.Type): + """Autogenerated return type of AddDiscussionPollVote""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "poll_option") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + poll_option = sgqlc.types.Field("DiscussionPollOption", graphql_name="pollOption") + """The poll option that a vote was added to.""" + + +class AddEnterpriseSupportEntitlementPayload(sgqlc.types.Type): + """Autogenerated return type of AddEnterpriseSupportEntitlement""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of adding the support entitlement.""" + + +class AddLabelsToLabelablePayload(sgqlc.types.Type): + """Autogenerated return type of AddLabelsToLabelable""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "labelable") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + labelable = sgqlc.types.Field("Labelable", graphql_name="labelable") + """The item that was labeled.""" + + +class AddProjectCardPayload(sgqlc.types.Type): + """Autogenerated return type of AddProjectCard""" + + __schema__ = github_schema + __field_names__ = ("card_edge", "client_mutation_id", "project_column") + card_edge = sgqlc.types.Field("ProjectCardEdge", graphql_name="cardEdge") + """The edge from the ProjectColumn's card connection.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_column = sgqlc.types.Field("ProjectColumn", graphql_name="projectColumn") + """The ProjectColumn""" + + +class AddProjectColumnPayload(sgqlc.types.Type): + """Autogenerated return type of AddProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "column_edge", "project") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + column_edge = sgqlc.types.Field("ProjectColumnEdge", graphql_name="columnEdge") + """The edge from the project's column connection.""" + + project = sgqlc.types.Field("Project", graphql_name="project") + """The project""" + + +class AddProjectDraftIssuePayload(sgqlc.types.Type): + """Autogenerated return type of AddProjectDraftIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project_next_item") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_next_item = sgqlc.types.Field("ProjectNextItem", graphql_name="projectNextItem") + """The draft issue added to the project.""" + + +class AddProjectNextItemPayload(sgqlc.types.Type): + """Autogenerated return type of AddProjectNextItem""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project_next_item") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_next_item = sgqlc.types.Field("ProjectNextItem", graphql_name="projectNextItem") + """The item added to the project.""" + + +class AddPullRequestReviewCommentPayload(sgqlc.types.Type): + """Autogenerated return type of AddPullRequestReviewComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "comment", "comment_edge") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + comment = sgqlc.types.Field("PullRequestReviewComment", graphql_name="comment") + """The newly created comment.""" + + comment_edge = sgqlc.types.Field("PullRequestReviewCommentEdge", graphql_name="commentEdge") + """The edge from the review's comment connection.""" + + +class AddPullRequestReviewPayload(sgqlc.types.Type): + """Autogenerated return type of AddPullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request_review", "review_edge") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request_review = sgqlc.types.Field("PullRequestReview", graphql_name="pullRequestReview") + """The newly created pull request review.""" + + review_edge = sgqlc.types.Field("PullRequestReviewEdge", graphql_name="reviewEdge") + """The edge from the pull request's review connection.""" + + +class AddPullRequestReviewThreadPayload(sgqlc.types.Type): + """Autogenerated return type of AddPullRequestReviewThread""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "thread") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + thread = sgqlc.types.Field("PullRequestReviewThread", graphql_name="thread") + """The newly created thread.""" + + +class AddReactionPayload(sgqlc.types.Type): + """Autogenerated return type of AddReaction""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "reaction", "subject") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + reaction = sgqlc.types.Field("Reaction", graphql_name="reaction") + """The reaction object.""" + + subject = sgqlc.types.Field("Reactable", graphql_name="subject") + """The reactable subject.""" + + +class AddStarPayload(sgqlc.types.Type): + """Autogenerated return type of AddStar""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "starrable") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + starrable = sgqlc.types.Field("Starrable", graphql_name="starrable") + """The starrable.""" + + +class AddUpvotePayload(sgqlc.types.Type): + """Autogenerated return type of AddUpvote""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "subject") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + subject = sgqlc.types.Field("Votable", graphql_name="subject") + """The votable subject.""" + + +class AddVerifiableDomainPayload(sgqlc.types.Type): + """Autogenerated return type of AddVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "domain") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + domain = sgqlc.types.Field("VerifiableDomain", graphql_name="domain") + """The verifiable domain that was added.""" + + +class ApproveDeploymentsPayload(sgqlc.types.Type): + """Autogenerated return type of ApproveDeployments""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "deployments") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + deployments = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("Deployment")), graphql_name="deployments") + """The affected deployments.""" + + +class ApproveVerifiableDomainPayload(sgqlc.types.Type): + """Autogenerated return type of ApproveVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "domain") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + domain = sgqlc.types.Field("VerifiableDomain", graphql_name="domain") + """The verifiable domain that was approved.""" + + +class ArchiveRepositoryPayload(sgqlc.types.Type): + """Autogenerated return type of ArchiveRepository""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository that was marked as archived.""" + + +class Assignable(sgqlc.types.Interface): + """An object that can have users assigned to it.""" + + __schema__ = github_schema + __field_names__ = ("assignees",) + assignees = sgqlc.types.Field( + sgqlc.types.non_null("UserConnection"), + graphql_name="assignees", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of Users assigned to this object. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class AuditEntry(sgqlc.types.Interface): + """An entry in the audit log.""" + + __schema__ = github_schema + __field_names__ = ( + "action", + "actor", + "actor_ip", + "actor_location", + "actor_login", + "actor_resource_path", + "actor_url", + "created_at", + "operation_type", + "user", + "user_login", + "user_resource_path", + "user_url", + ) + action = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="action") + """The action name""" + + actor = sgqlc.types.Field("AuditEntryActor", graphql_name="actor") + """The user who initiated the action""" + + actor_ip = sgqlc.types.Field(String, graphql_name="actorIp") + """The IP address of the actor""" + + actor_location = sgqlc.types.Field(ActorLocation, graphql_name="actorLocation") + """A readable representation of the actor's location""" + + actor_login = sgqlc.types.Field(String, graphql_name="actorLogin") + """The username of the user who initiated the action""" + + actor_resource_path = sgqlc.types.Field(URI, graphql_name="actorResourcePath") + """The HTTP path for the actor.""" + + actor_url = sgqlc.types.Field(URI, graphql_name="actorUrl") + """The HTTP URL for the actor.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(PreciseDateTime), graphql_name="createdAt") + """The time the action was initiated""" + + operation_type = sgqlc.types.Field(OperationType, graphql_name="operationType") + """The corresponding operation type for the action""" + + user = sgqlc.types.Field("User", graphql_name="user") + """The user affected by the action""" + + user_login = sgqlc.types.Field(String, graphql_name="userLogin") + """For actions involving two users, the actor is the initiator and + the user is the affected user. + """ + + user_resource_path = sgqlc.types.Field(URI, graphql_name="userResourcePath") + """The HTTP path for the user.""" + + user_url = sgqlc.types.Field(URI, graphql_name="userUrl") + """The HTTP URL for the user.""" + + +class AutoMergeRequest(sgqlc.types.Type): + """Represents an auto-merge request for a pull request""" + + __schema__ = github_schema + __field_names__ = ("author_email", "commit_body", "commit_headline", "enabled_at", "enabled_by", "merge_method", "pull_request") + author_email = sgqlc.types.Field(String, graphql_name="authorEmail") + """The email address of the author of this auto-merge request.""" + + commit_body = sgqlc.types.Field(String, graphql_name="commitBody") + """The commit message of the auto-merge request. If a merge queue is + required by the base branch, this value will be set by the merge + queue when merging. + """ + + commit_headline = sgqlc.types.Field(String, graphql_name="commitHeadline") + """The commit title of the auto-merge request. If a merge queue is + required by the base branch, this value will be set by the merge + queue when merging + """ + + enabled_at = sgqlc.types.Field(DateTime, graphql_name="enabledAt") + """When was this auto-merge request was enabled.""" + + enabled_by = sgqlc.types.Field(Actor, graphql_name="enabledBy") + """The actor who created the auto-merge request.""" + + merge_method = sgqlc.types.Field(sgqlc.types.non_null(PullRequestMergeMethod), graphql_name="mergeMethod") + """The merge method of the auto-merge request. If a merge queue is + required by the base branch, this value will be set by the merge + queue when merging. + """ + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """The pull request that this auto-merge request is set against.""" + + +class Blame(sgqlc.types.Type): + """Represents a Git blame.""" + + __schema__ = github_schema + __field_names__ = ("ranges",) + ranges = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("BlameRange"))), graphql_name="ranges") + """The list of ranges from a Git blame.""" + + +class BlameRange(sgqlc.types.Type): + """Represents a range of information from a Git blame.""" + + __schema__ = github_schema + __field_names__ = ("age", "commit", "ending_line", "starting_line") + age = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="age") + """Identifies the recency of the change, from 1 (new) to 10 (old). + This is calculated as a 2-quantile and determines the length of + distance between the median age of all the changes in the file and + the recency of the current range's change. + """ + + commit = sgqlc.types.Field(sgqlc.types.non_null("Commit"), graphql_name="commit") + """Identifies the line author""" + + ending_line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="endingLine") + """The ending line for the range""" + + starting_line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="startingLine") + """The starting line for the range""" + + +class BranchProtectionRuleConflict(sgqlc.types.Type): + """A conflict between two branch protection rules.""" + + __schema__ = github_schema + __field_names__ = ("branch_protection_rule", "conflicting_branch_protection_rule", "ref") + branch_protection_rule = sgqlc.types.Field("BranchProtectionRule", graphql_name="branchProtectionRule") + """Identifies the branch protection rule.""" + + conflicting_branch_protection_rule = sgqlc.types.Field("BranchProtectionRule", graphql_name="conflictingBranchProtectionRule") + """Identifies the conflicting branch protection rule.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """Identifies the branch ref that has conflicting rules""" + + +class BranchProtectionRuleConflictConnection(sgqlc.types.relay.Connection): + """The connection type for BranchProtectionRuleConflict.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("BranchProtectionRuleConflictEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(BranchProtectionRuleConflict), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class BranchProtectionRuleConflictEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(BranchProtectionRuleConflict, graphql_name="node") + """The item at the end of the edge.""" + + +class BranchProtectionRuleConnection(sgqlc.types.relay.Connection): + """The connection type for BranchProtectionRule.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("BranchProtectionRuleEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("BranchProtectionRule"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class BranchProtectionRuleEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("BranchProtectionRule", graphql_name="node") + """The item at the end of the edge.""" + + +class BypassForcePushAllowanceConnection(sgqlc.types.relay.Connection): + """The connection type for BypassForcePushAllowance.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("BypassForcePushAllowanceEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("BypassForcePushAllowance"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class BypassForcePushAllowanceEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("BypassForcePushAllowance", graphql_name="node") + """The item at the end of the edge.""" + + +class BypassPullRequestAllowanceConnection(sgqlc.types.relay.Connection): + """The connection type for BypassPullRequestAllowance.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("BypassPullRequestAllowanceEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("BypassPullRequestAllowance"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class BypassPullRequestAllowanceEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("BypassPullRequestAllowance", graphql_name="node") + """The item at the end of the edge.""" + + +class CVSS(sgqlc.types.Type): + """The Common Vulnerability Scoring System""" + + __schema__ = github_schema + __field_names__ = ("score", "vector_string") + score = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="score") + """The CVSS score associated with this advisory""" + + vector_string = sgqlc.types.Field(String, graphql_name="vectorString") + """The CVSS vector string associated with this advisory""" + + +class CWEConnection(sgqlc.types.relay.Connection): + """The connection type for CWE.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CWEEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CWE"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CWEEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CWE", graphql_name="node") + """The item at the end of the edge.""" + + +class CancelEnterpriseAdminInvitationPayload(sgqlc.types.Type): + """Autogenerated return type of CancelEnterpriseAdminInvitation""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "invitation", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + invitation = sgqlc.types.Field("EnterpriseAdministratorInvitation", graphql_name="invitation") + """The invitation that was canceled.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of canceling an administrator + invitation. + """ + + +class CancelSponsorshipPayload(sgqlc.types.Type): + """Autogenerated return type of CancelSponsorship""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "sponsors_tier") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + sponsors_tier = sgqlc.types.Field("SponsorsTier", graphql_name="sponsorsTier") + """The tier that was being used at the time of cancellation.""" + + +class ChangeUserStatusPayload(sgqlc.types.Type): + """Autogenerated return type of ChangeUserStatus""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "status") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + status = sgqlc.types.Field("UserStatus", graphql_name="status") + """Your updated status.""" + + +class CheckAnnotation(sgqlc.types.Type): + """A single check annotation.""" + + __schema__ = github_schema + __field_names__ = ("annotation_level", "blob_url", "database_id", "location", "message", "path", "raw_details", "title") + annotation_level = sgqlc.types.Field(CheckAnnotationLevel, graphql_name="annotationLevel") + """The annotation's severity level.""" + + blob_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="blobUrl") + """The path to the file that this annotation was made on.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + location = sgqlc.types.Field(sgqlc.types.non_null("CheckAnnotationSpan"), graphql_name="location") + """The position of this annotation.""" + + message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message") + """The annotation's message.""" + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path that this annotation was made on.""" + + raw_details = sgqlc.types.Field(String, graphql_name="rawDetails") + """Additional information about the annotation.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The annotation's title""" + + +class CheckAnnotationConnection(sgqlc.types.relay.Connection): + """The connection type for CheckAnnotation.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CheckAnnotationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(CheckAnnotation), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CheckAnnotationEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(CheckAnnotation, graphql_name="node") + """The item at the end of the edge.""" + + +class CheckAnnotationPosition(sgqlc.types.Type): + """A character position in a check annotation.""" + + __schema__ = github_schema + __field_names__ = ("column", "line") + column = sgqlc.types.Field(Int, graphql_name="column") + """Column number (1 indexed).""" + + line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="line") + """Line number (1 indexed).""" + + +class CheckAnnotationSpan(sgqlc.types.Type): + """An inclusive pair of positions for a check annotation.""" + + __schema__ = github_schema + __field_names__ = ("end", "start") + end = sgqlc.types.Field(sgqlc.types.non_null(CheckAnnotationPosition), graphql_name="end") + """End position (inclusive).""" + + start = sgqlc.types.Field(sgqlc.types.non_null(CheckAnnotationPosition), graphql_name="start") + """Start position (inclusive).""" + + +class CheckRunConnection(sgqlc.types.relay.Connection): + """The connection type for CheckRun.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CheckRunEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CheckRun"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CheckRunEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CheckRun", graphql_name="node") + """The item at the end of the edge.""" + + +class CheckStep(sgqlc.types.Type): + """A single check step.""" + + __schema__ = github_schema + __field_names__ = ("completed_at", "conclusion", "external_id", "name", "number", "seconds_to_completion", "started_at", "status") + completed_at = sgqlc.types.Field(DateTime, graphql_name="completedAt") + """Identifies the date and time when the check step was completed.""" + + conclusion = sgqlc.types.Field(CheckConclusionState, graphql_name="conclusion") + """The conclusion of the check step.""" + + external_id = sgqlc.types.Field(String, graphql_name="externalId") + """A reference for the check step on the integrator's system.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The step's name.""" + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """The index of the step in the list of steps of the parent check + run. + """ + + seconds_to_completion = sgqlc.types.Field(Int, graphql_name="secondsToCompletion") + """Number of seconds to completion.""" + + started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt") + """Identifies the date and time when the check step was started.""" + + status = sgqlc.types.Field(sgqlc.types.non_null(CheckStatusState), graphql_name="status") + """The current status of the check step.""" + + +class CheckStepConnection(sgqlc.types.relay.Connection): + """The connection type for CheckStep.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CheckStepEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(CheckStep), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CheckStepEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(CheckStep, graphql_name="node") + """The item at the end of the edge.""" + + +class CheckSuiteConnection(sgqlc.types.relay.Connection): + """The connection type for CheckSuite.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CheckSuiteEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CheckSuite"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CheckSuiteEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CheckSuite", graphql_name="node") + """The item at the end of the edge.""" + + +class ClearLabelsFromLabelablePayload(sgqlc.types.Type): + """Autogenerated return type of ClearLabelsFromLabelable""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "labelable") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + labelable = sgqlc.types.Field("Labelable", graphql_name="labelable") + """The item that was unlabeled.""" + + +class CloneProjectPayload(sgqlc.types.Type): + """Autogenerated return type of CloneProject""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "job_status_id", "project") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + job_status_id = sgqlc.types.Field(String, graphql_name="jobStatusId") + """The id of the JobStatus for populating cloned fields.""" + + project = sgqlc.types.Field("Project", graphql_name="project") + """The new cloned project.""" + + +class CloneTemplateRepositoryPayload(sgqlc.types.Type): + """Autogenerated return type of CloneTemplateRepository""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The new repository.""" + + +class Closable(sgqlc.types.Interface): + """An object that can be closed""" + + __schema__ = github_schema + __field_names__ = ("closed", "closed_at") + closed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="closed") + """`true` if the object is closed (definition of closed may depend on + type) + """ + + closed_at = sgqlc.types.Field(DateTime, graphql_name="closedAt") + """Identifies the date and time when the object was closed.""" + + +class CloseIssuePayload(sgqlc.types.Type): + """Autogenerated return type of CloseIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "issue") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue = sgqlc.types.Field("Issue", graphql_name="issue") + """The issue that was closed.""" + + +class ClosePullRequestPayload(sgqlc.types.Type): + """Autogenerated return type of ClosePullRequest""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request that was closed.""" + + +class Comment(sgqlc.types.Interface): + """Represents a comment.""" + + __schema__ = github_schema + __field_names__ = ( + "author", + "author_association", + "body", + "body_html", + "body_text", + "created_at", + "created_via_email", + "editor", + "id", + "includes_created_edit", + "last_edited_at", + "published_at", + "updated_at", + "user_content_edits", + "viewer_did_author", + ) + author = sgqlc.types.Field(Actor, graphql_name="author") + """The actor who authored the comment.""" + + author_association = sgqlc.types.Field(sgqlc.types.non_null(CommentAuthorAssociation), graphql_name="authorAssociation") + """Author's association with the subject of the comment.""" + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The body as Markdown.""" + + body_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="bodyHTML") + """The body rendered to HTML.""" + + body_text = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="bodyText") + """The body rendered to text.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + created_via_email = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="createdViaEmail") + """Check if this comment was created via an email reply.""" + + editor = sgqlc.types.Field(Actor, graphql_name="editor") + """The actor who edited the comment.""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + includes_created_edit = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="includesCreatedEdit") + """Check if this comment was edited and includes an edit with the + creation data + """ + + last_edited_at = sgqlc.types.Field(DateTime, graphql_name="lastEditedAt") + """The moment the editor made the last edit""" + + published_at = sgqlc.types.Field(DateTime, graphql_name="publishedAt") + """Identifies when the comment was published at.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + user_content_edits = sgqlc.types.Field( + "UserContentEditConnection", + graphql_name="userContentEdits", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of edits to this content. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + viewer_did_author = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerDidAuthor") + """Did the viewer author this comment.""" + + +class CommitCommentConnection(sgqlc.types.relay.Connection): + """The connection type for CommitComment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CommitCommentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CommitComment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CommitCommentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CommitComment", graphql_name="node") + """The item at the end of the edge.""" + + +class CommitConnection(sgqlc.types.relay.Connection): + """The connection type for Commit.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CommitEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Commit"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CommitContributionsByRepository(sgqlc.types.Type): + """This aggregates commits made by a user within one repository.""" + + __schema__ = github_schema + __field_names__ = ("contributions", "repository", "resource_path", "url") + contributions = sgqlc.types.Field( + sgqlc.types.non_null("CreatedCommitContributionConnection"), + graphql_name="contributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg(CommitContributionOrder, graphql_name="orderBy", default={"field": "OCCURRED_AT", "direction": "DESC"}), + ), + ) + ), + ) + """The commit contributions, each representing a day. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`CommitContributionOrder`): Ordering options for + commit contributions returned from the connection. (default: + `{field: OCCURRED_AT, direction: DESC}`) + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository in which the commits were made.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for the user's commits to the repository in this + time range. + """ + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for the user's commits to the repository in this time + range. + """ + + +class CommitEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Commit", graphql_name="node") + """The item at the end of the edge.""" + + +class CommitHistoryConnection(sgqlc.types.relay.Connection): + """The connection type for Commit.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of(CommitEdge), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Commit"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class Contribution(sgqlc.types.Interface): + """Represents a contribution a user made on GitHub, such as opening + an issue. + """ + + __schema__ = github_schema + __field_names__ = ("is_restricted", "occurred_at", "resource_path", "url", "user") + is_restricted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isRestricted") + """Whether this contribution is associated with a record you do not + have access to. For example, your own 'first issue' contribution + may have been made on a repository you can no longer access. + """ + + occurred_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="occurredAt") + """When this contribution was made.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this contribution.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this contribution.""" + + user = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="user") + """The user who made this contribution.""" + + +class ContributionCalendar(sgqlc.types.Type): + """A calendar of contributions made on GitHub by a user.""" + + __schema__ = github_schema + __field_names__ = ("colors", "is_halloween", "months", "total_contributions", "weeks") + colors = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))), graphql_name="colors") + """A list of hex color codes used in this calendar. The darker the + color, the more contributions it represents. + """ + + is_halloween = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isHalloween") + """Determine if the color set was chosen because it's currently + Halloween. + """ + + months = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("ContributionCalendarMonth"))), graphql_name="months" + ) + """A list of the months of contributions in this calendar.""" + + total_contributions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalContributions") + """The count of total contributions in the calendar.""" + + weeks = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("ContributionCalendarWeek"))), graphql_name="weeks" + ) + """A list of the weeks of contributions in this calendar.""" + + +class ContributionCalendarDay(sgqlc.types.Type): + """Represents a single day of contributions on GitHub by a user.""" + + __schema__ = github_schema + __field_names__ = ("color", "contribution_count", "contribution_level", "date", "weekday") + color = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="color") + """The hex color code that represents how many contributions were + made on this day compared to others in the calendar. + """ + + contribution_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="contributionCount") + """How many contributions were made by the user on this day.""" + + contribution_level = sgqlc.types.Field(sgqlc.types.non_null(ContributionLevel), graphql_name="contributionLevel") + """Indication of contributions, relative to other days. Can be used + to indicate which color to represent this day on a calendar. + """ + + date = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="date") + """The day this square represents.""" + + weekday = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="weekday") + """A number representing which day of the week this square + represents, e.g., 1 is Monday. + """ + + +class ContributionCalendarMonth(sgqlc.types.Type): + """A month of contributions in a user's contribution graph.""" + + __schema__ = github_schema + __field_names__ = ("first_day", "name", "total_weeks", "year") + first_day = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="firstDay") + """The date of the first day of this month.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the month.""" + + total_weeks = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalWeeks") + """How many weeks started in this month.""" + + year = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="year") + """The year the month occurred in.""" + + +class ContributionCalendarWeek(sgqlc.types.Type): + """A week of contributions in a user's contribution graph.""" + + __schema__ = github_schema + __field_names__ = ("contribution_days", "first_day") + contribution_days = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ContributionCalendarDay))), graphql_name="contributionDays" + ) + """The days of contributions in this week.""" + + first_day = sgqlc.types.Field(sgqlc.types.non_null(Date), graphql_name="firstDay") + """The date of the earliest square in this week.""" + + +class ContributionsCollection(sgqlc.types.Type): + """A contributions collection aggregates contributions such as opened + issues and commits created by a user. + """ + + __schema__ = github_schema + __field_names__ = ( + "commit_contributions_by_repository", + "contribution_calendar", + "contribution_years", + "does_end_in_current_month", + "earliest_restricted_contribution_date", + "ended_at", + "first_issue_contribution", + "first_pull_request_contribution", + "first_repository_contribution", + "has_activity_in_the_past", + "has_any_contributions", + "has_any_restricted_contributions", + "is_single_day", + "issue_contributions", + "issue_contributions_by_repository", + "joined_git_hub_contribution", + "latest_restricted_contribution_date", + "most_recent_collection_with_activity", + "most_recent_collection_without_activity", + "popular_issue_contribution", + "popular_pull_request_contribution", + "pull_request_contributions", + "pull_request_contributions_by_repository", + "pull_request_review_contributions", + "pull_request_review_contributions_by_repository", + "repository_contributions", + "restricted_contributions_count", + "started_at", + "total_commit_contributions", + "total_issue_contributions", + "total_pull_request_contributions", + "total_pull_request_review_contributions", + "total_repositories_with_contributed_commits", + "total_repositories_with_contributed_issues", + "total_repositories_with_contributed_pull_request_reviews", + "total_repositories_with_contributed_pull_requests", + "total_repository_contributions", + "user", + ) + commit_contributions_by_repository = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(CommitContributionsByRepository))), + graphql_name="commitContributionsByRepository", + args=sgqlc.types.ArgDict((("max_repositories", sgqlc.types.Arg(Int, graphql_name="maxRepositories", default=25)),)), + ) + """Commit contributions made by the user, grouped by repository. + + Arguments: + + * `max_repositories` (`Int`): How many repositories should be + included. (default: `25`) + """ + + contribution_calendar = sgqlc.types.Field(sgqlc.types.non_null(ContributionCalendar), graphql_name="contributionCalendar") + """A calendar of this user's contributions on GitHub.""" + + contribution_years = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(Int))), graphql_name="contributionYears" + ) + """The years the user has been making contributions with the most + recent year first. + """ + + does_end_in_current_month = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="doesEndInCurrentMonth") + """Determine if this collection's time span ends in the current + month. + """ + + earliest_restricted_contribution_date = sgqlc.types.Field(Date, graphql_name="earliestRestrictedContributionDate") + """The date of the first restricted contribution the user made in + this time period. Can only be non-null when the user has enabled + private contribution counts. + """ + + ended_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="endedAt") + """The ending date and time of this collection.""" + + first_issue_contribution = sgqlc.types.Field("CreatedIssueOrRestrictedContribution", graphql_name="firstIssueContribution") + """The first issue the user opened on GitHub. This will be null if + that issue was opened outside the collection's time range and + ignoreTimeRange is false. If the issue is not visible but the user + has opted to show private contributions, a RestrictedContribution + will be returned. + """ + + first_pull_request_contribution = sgqlc.types.Field( + "CreatedPullRequestOrRestrictedContribution", graphql_name="firstPullRequestContribution" + ) + """The first pull request the user opened on GitHub. This will be + null if that pull request was opened outside the collection's time + range and ignoreTimeRange is not true. If the pull request is not + visible but the user has opted to show private contributions, a + RestrictedContribution will be returned. + """ + + first_repository_contribution = sgqlc.types.Field( + "CreatedRepositoryOrRestrictedContribution", graphql_name="firstRepositoryContribution" + ) + """The first repository the user created on GitHub. This will be null + if that first repository was created outside the collection's time + range and ignoreTimeRange is false. If the repository is not + visible, then a RestrictedContribution is returned. + """ + + has_activity_in_the_past = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasActivityInThePast") + """Does the user have any more activity in the timeline that occurred + prior to the collection's time range? + """ + + has_any_contributions = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasAnyContributions") + """Determine if there are any contributions in this collection.""" + + has_any_restricted_contributions = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasAnyRestrictedContributions") + """Determine if the user made any contributions in this time frame + whose details are not visible because they were made in a private + repository. Can only be true if the user enabled private + contribution counts. + """ + + is_single_day = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSingleDay") + """Whether or not the collector's time span is all within the same + day. + """ + + issue_contributions = sgqlc.types.Field( + sgqlc.types.non_null("CreatedIssueContributionConnection"), + graphql_name="issueContributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ("order_by", sgqlc.types.Arg(ContributionOrder, graphql_name="orderBy", default={"direction": "DESC"})), + ) + ), + ) + """A list of issues the user opened. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `exclude_first` (`Boolean`): Should the user's first issue ever + be excluded from the result. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + issue be excluded from the result. (default: `false`) + * `order_by` (`ContributionOrder`): Ordering options for + contributions returned from the connection. (default: + `{direction: DESC}`) + """ + + issue_contributions_by_repository = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("IssueContributionsByRepository"))), + graphql_name="issueContributionsByRepository", + args=sgqlc.types.ArgDict( + ( + ("max_repositories", sgqlc.types.Arg(Int, graphql_name="maxRepositories", default=25)), + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ) + ), + ) + """Issue contributions made by the user, grouped by repository. + + Arguments: + + * `max_repositories` (`Int`): How many repositories should be + included. (default: `25`) + * `exclude_first` (`Boolean`): Should the user's first issue ever + be excluded from the result. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + issue be excluded from the result. (default: `false`) + """ + + joined_git_hub_contribution = sgqlc.types.Field("JoinedGitHubContribution", graphql_name="joinedGitHubContribution") + """When the user signed up for GitHub. This will be null if that sign + up date falls outside the collection's time range and + ignoreTimeRange is false. + """ + + latest_restricted_contribution_date = sgqlc.types.Field(Date, graphql_name="latestRestrictedContributionDate") + """The date of the most recent restricted contribution the user made + in this time period. Can only be non-null when the user has + enabled private contribution counts. + """ + + most_recent_collection_with_activity = sgqlc.types.Field("ContributionsCollection", graphql_name="mostRecentCollectionWithActivity") + """When this collection's time range does not include any activity + from the user, use this to get a different collection from an + earlier time range that does have activity. + """ + + most_recent_collection_without_activity = sgqlc.types.Field( + "ContributionsCollection", graphql_name="mostRecentCollectionWithoutActivity" + ) + """Returns a different contributions collection from an earlier time + range than this one that does not have any contributions. + """ + + popular_issue_contribution = sgqlc.types.Field("CreatedIssueContribution", graphql_name="popularIssueContribution") + """The issue the user opened on GitHub that received the most + comments in the specified time frame. + """ + + popular_pull_request_contribution = sgqlc.types.Field("CreatedPullRequestContribution", graphql_name="popularPullRequestContribution") + """The pull request the user opened on GitHub that received the most + comments in the specified time frame. + """ + + pull_request_contributions = sgqlc.types.Field( + sgqlc.types.non_null("CreatedPullRequestContributionConnection"), + graphql_name="pullRequestContributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ("order_by", sgqlc.types.Arg(ContributionOrder, graphql_name="orderBy", default={"direction": "DESC"})), + ) + ), + ) + """Pull request contributions made by the user. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `exclude_first` (`Boolean`): Should the user's first pull + request ever be excluded from the result. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + pull request be excluded from the result. (default: `false`) + * `order_by` (`ContributionOrder`): Ordering options for + contributions returned from the connection. (default: + `{direction: DESC}`) + """ + + pull_request_contributions_by_repository = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("PullRequestContributionsByRepository"))), + graphql_name="pullRequestContributionsByRepository", + args=sgqlc.types.ArgDict( + ( + ("max_repositories", sgqlc.types.Arg(Int, graphql_name="maxRepositories", default=25)), + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ) + ), + ) + """Pull request contributions made by the user, grouped by + repository. + + Arguments: + + * `max_repositories` (`Int`): How many repositories should be + included. (default: `25`) + * `exclude_first` (`Boolean`): Should the user's first pull + request ever be excluded from the result. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + pull request be excluded from the result. (default: `false`) + """ + + pull_request_review_contributions = sgqlc.types.Field( + sgqlc.types.non_null("CreatedPullRequestReviewContributionConnection"), + graphql_name="pullRequestReviewContributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(ContributionOrder, graphql_name="orderBy", default={"direction": "DESC"})), + ) + ), + ) + """Pull request review contributions made by the user. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`ContributionOrder`): Ordering options for + contributions returned from the connection. (default: + `{direction: DESC}`) + """ + + pull_request_review_contributions_by_repository = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("PullRequestReviewContributionsByRepository"))), + graphql_name="pullRequestReviewContributionsByRepository", + args=sgqlc.types.ArgDict((("max_repositories", sgqlc.types.Arg(Int, graphql_name="maxRepositories", default=25)),)), + ) + """Pull request review contributions made by the user, grouped by + repository. + + Arguments: + + * `max_repositories` (`Int`): How many repositories should be + included. (default: `25`) + """ + + repository_contributions = sgqlc.types.Field( + sgqlc.types.non_null("CreatedRepositoryContributionConnection"), + graphql_name="repositoryContributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("order_by", sgqlc.types.Arg(ContributionOrder, graphql_name="orderBy", default={"direction": "DESC"})), + ) + ), + ) + """A list of repositories owned by the user that the user created in + this time range. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `exclude_first` (`Boolean`): Should the user's first repository + ever be excluded from the result. (default: `false`) + * `order_by` (`ContributionOrder`): Ordering options for + contributions returned from the connection. (default: + `{direction: DESC}`) + """ + + restricted_contributions_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="restrictedContributionsCount") + """A count of contributions made by the user that the viewer cannot + access. Only non-zero when the user has chosen to share their + private contribution counts. + """ + + started_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="startedAt") + """The beginning date and time of this collection.""" + + total_commit_contributions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCommitContributions") + """How many commits were made by the user in this time span.""" + + total_issue_contributions = sgqlc.types.Field( + sgqlc.types.non_null(Int), + graphql_name="totalIssueContributions", + args=sgqlc.types.ArgDict( + ( + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ) + ), + ) + """How many issues the user opened. + + Arguments: + + * `exclude_first` (`Boolean`): Should the user's first issue ever + be excluded from this count. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + issue be excluded from this count. (default: `false`) + """ + + total_pull_request_contributions = sgqlc.types.Field( + sgqlc.types.non_null(Int), + graphql_name="totalPullRequestContributions", + args=sgqlc.types.ArgDict( + ( + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ) + ), + ) + """How many pull requests the user opened. + + Arguments: + + * `exclude_first` (`Boolean`): Should the user's first pull + request ever be excluded from this count. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + pull request be excluded from this count. (default: `false`) + """ + + total_pull_request_review_contributions = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalPullRequestReviewContributions" + ) + """How many pull request reviews the user left.""" + + total_repositories_with_contributed_commits = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalRepositoriesWithContributedCommits" + ) + """How many different repositories the user committed to.""" + + total_repositories_with_contributed_issues = sgqlc.types.Field( + sgqlc.types.non_null(Int), + graphql_name="totalRepositoriesWithContributedIssues", + args=sgqlc.types.ArgDict( + ( + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ) + ), + ) + """How many different repositories the user opened issues in. + + Arguments: + + * `exclude_first` (`Boolean`): Should the user's first issue ever + be excluded from this count. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + issue be excluded from this count. (default: `false`) + """ + + total_repositories_with_contributed_pull_request_reviews = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalRepositoriesWithContributedPullRequestReviews" + ) + """How many different repositories the user left pull request reviews + in. + """ + + total_repositories_with_contributed_pull_requests = sgqlc.types.Field( + sgqlc.types.non_null(Int), + graphql_name="totalRepositoriesWithContributedPullRequests", + args=sgqlc.types.ArgDict( + ( + ("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)), + ("exclude_popular", sgqlc.types.Arg(Boolean, graphql_name="excludePopular", default=False)), + ) + ), + ) + """How many different repositories the user opened pull requests in. + + Arguments: + + * `exclude_first` (`Boolean`): Should the user's first pull + request ever be excluded from this count. (default: `false`) + * `exclude_popular` (`Boolean`): Should the user's most commented + pull request be excluded from this count. (default: `false`) + """ + + total_repository_contributions = sgqlc.types.Field( + sgqlc.types.non_null(Int), + graphql_name="totalRepositoryContributions", + args=sgqlc.types.ArgDict((("exclude_first", sgqlc.types.Arg(Boolean, graphql_name="excludeFirst", default=False)),)), + ) + """How many repositories the user created. + + Arguments: + + * `exclude_first` (`Boolean`): Should the user's first repository + ever be excluded from this count. (default: `false`) + """ + + user = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="user") + """The user who made the contributions in this collection.""" + + +class ConvertProjectCardNoteToIssuePayload(sgqlc.types.Type): + """Autogenerated return type of ConvertProjectCardNoteToIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project_card") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_card = sgqlc.types.Field("ProjectCard", graphql_name="projectCard") + """The updated ProjectCard.""" + + +class ConvertPullRequestToDraftPayload(sgqlc.types.Type): + """Autogenerated return type of ConvertPullRequestToDraft""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request that is now a draft.""" + + +class CreateBranchProtectionRulePayload(sgqlc.types.Type): + """Autogenerated return type of CreateBranchProtectionRule""" + + __schema__ = github_schema + __field_names__ = ("branch_protection_rule", "client_mutation_id") + branch_protection_rule = sgqlc.types.Field("BranchProtectionRule", graphql_name="branchProtectionRule") + """The newly created BranchProtectionRule.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateCheckRunPayload(sgqlc.types.Type): + """Autogenerated return type of CreateCheckRun""" + + __schema__ = github_schema + __field_names__ = ("check_run", "client_mutation_id") + check_run = sgqlc.types.Field("CheckRun", graphql_name="checkRun") + """The newly created check run.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateCheckSuitePayload(sgqlc.types.Type): + """Autogenerated return type of CreateCheckSuite""" + + __schema__ = github_schema + __field_names__ = ("check_suite", "client_mutation_id") + check_suite = sgqlc.types.Field("CheckSuite", graphql_name="checkSuite") + """The newly created check suite.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class CreateCommitOnBranchPayload(sgqlc.types.Type): + """Autogenerated return type of CreateCommitOnBranch""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "commit", "ref") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + commit = sgqlc.types.Field("Commit", graphql_name="commit") + """The new commit.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """The ref which has been updated to point to the new commit.""" + + +class CreateDiscussionPayload(sgqlc.types.Type): + """Autogenerated return type of CreateDiscussion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "discussion") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + discussion = sgqlc.types.Field("Discussion", graphql_name="discussion") + """The discussion that was just created.""" + + +class CreateEnterpriseOrganizationPayload(sgqlc.types.Type): + """Autogenerated return type of CreateEnterpriseOrganization""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "organization") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise that owns the created organization.""" + + organization = sgqlc.types.Field("Organization", graphql_name="organization") + """The organization that was created.""" + + +class CreateEnvironmentPayload(sgqlc.types.Type): + """Autogenerated return type of CreateEnvironment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "environment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + environment = sgqlc.types.Field("Environment", graphql_name="environment") + """The new or existing environment.""" + + +class CreateIpAllowListEntryPayload(sgqlc.types.Type): + """Autogenerated return type of CreateIpAllowListEntry""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "ip_allow_list_entry") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + ip_allow_list_entry = sgqlc.types.Field("IpAllowListEntry", graphql_name="ipAllowListEntry") + """The IP allow list entry that was created.""" + + +class CreateIssuePayload(sgqlc.types.Type): + """Autogenerated return type of CreateIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "issue") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue = sgqlc.types.Field("Issue", graphql_name="issue") + """The new issue.""" + + +class CreateMigrationSourcePayload(sgqlc.types.Type): + """Autogenerated return type of CreateMigrationSource""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "migration_source") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + migration_source = sgqlc.types.Field("MigrationSource", graphql_name="migrationSource") + """The created Octoshift migration source.""" + + +class CreateProjectPayload(sgqlc.types.Type): + """Autogenerated return type of CreateProject""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project = sgqlc.types.Field("Project", graphql_name="project") + """The new project.""" + + +class CreatePullRequestPayload(sgqlc.types.Type): + """Autogenerated return type of CreatePullRequest""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The new pull request.""" + + +class CreateRefPayload(sgqlc.types.Type): + """Autogenerated return type of CreateRef""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "ref") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """The newly created ref.""" + + +class CreateRepositoryPayload(sgqlc.types.Type): + """Autogenerated return type of CreateRepository""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The new repository.""" + + +class CreateSponsorsTierPayload(sgqlc.types.Type): + """Autogenerated return type of CreateSponsorsTier""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "sponsors_tier") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + sponsors_tier = sgqlc.types.Field("SponsorsTier", graphql_name="sponsorsTier") + """The new tier.""" + + +class CreateSponsorshipPayload(sgqlc.types.Type): + """Autogenerated return type of CreateSponsorship""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "sponsorship") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + sponsorship = sgqlc.types.Field("Sponsorship", graphql_name="sponsorship") + """The sponsorship that was started.""" + + +class CreateTeamDiscussionCommentPayload(sgqlc.types.Type): + """Autogenerated return type of CreateTeamDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "team_discussion_comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + team_discussion_comment = sgqlc.types.Field("TeamDiscussionComment", graphql_name="teamDiscussionComment") + """The new comment.""" + + +class CreateTeamDiscussionPayload(sgqlc.types.Type): + """Autogenerated return type of CreateTeamDiscussion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "team_discussion") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + team_discussion = sgqlc.types.Field("TeamDiscussion", graphql_name="teamDiscussion") + """The new discussion.""" + + +class CreatedCommitContributionConnection(sgqlc.types.relay.Connection): + """The connection type for CreatedCommitContribution.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CreatedCommitContributionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CreatedCommitContribution"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of commits across days and repositories + in the connection. + """ + + +class CreatedCommitContributionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CreatedCommitContribution", graphql_name="node") + """The item at the end of the edge.""" + + +class CreatedIssueContributionConnection(sgqlc.types.relay.Connection): + """The connection type for CreatedIssueContribution.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CreatedIssueContributionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CreatedIssueContribution"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CreatedIssueContributionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CreatedIssueContribution", graphql_name="node") + """The item at the end of the edge.""" + + +class CreatedPullRequestContributionConnection(sgqlc.types.relay.Connection): + """The connection type for CreatedPullRequestContribution.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CreatedPullRequestContributionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CreatedPullRequestContribution"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CreatedPullRequestContributionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CreatedPullRequestContribution", graphql_name="node") + """The item at the end of the edge.""" + + +class CreatedPullRequestReviewContributionConnection(sgqlc.types.relay.Connection): + """The connection type for CreatedPullRequestReviewContribution.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CreatedPullRequestReviewContributionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CreatedPullRequestReviewContribution"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CreatedPullRequestReviewContributionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CreatedPullRequestReviewContribution", graphql_name="node") + """The item at the end of the edge.""" + + +class CreatedRepositoryContributionConnection(sgqlc.types.relay.Connection): + """The connection type for CreatedRepositoryContribution.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("CreatedRepositoryContributionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("CreatedRepositoryContribution"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class CreatedRepositoryContributionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("CreatedRepositoryContribution", graphql_name="node") + """The item at the end of the edge.""" + + +class DeclineTopicSuggestionPayload(sgqlc.types.Type): + """Autogenerated return type of DeclineTopicSuggestion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "topic") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + topic = sgqlc.types.Field("Topic", graphql_name="topic") + """The declined topic.""" + + +class Deletable(sgqlc.types.Interface): + """Entities that can be deleted.""" + + __schema__ = github_schema + __field_names__ = ("viewer_can_delete",) + viewer_can_delete = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanDelete") + """Check if the current viewer can delete this object.""" + + +class DeleteBranchProtectionRulePayload(sgqlc.types.Type): + """Autogenerated return type of DeleteBranchProtectionRule""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id",) + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteDeploymentPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteDeployment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id",) + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteDiscussionCommentPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + comment = sgqlc.types.Field("DiscussionComment", graphql_name="comment") + """The discussion comment that was just deleted.""" + + +class DeleteDiscussionPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteDiscussion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "discussion") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + discussion = sgqlc.types.Field("Discussion", graphql_name="discussion") + """The discussion that was just deleted.""" + + +class DeleteEnvironmentPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteEnvironment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id",) + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteIpAllowListEntryPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteIpAllowListEntry""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "ip_allow_list_entry") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + ip_allow_list_entry = sgqlc.types.Field("IpAllowListEntry", graphql_name="ipAllowListEntry") + """The IP allow list entry that was deleted.""" + + +class DeleteIssueCommentPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteIssueComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id",) + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteIssuePayload(sgqlc.types.Type): + """Autogenerated return type of DeleteIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository the issue belonged to""" + + +class DeleteProjectCardPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteProjectCard""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "column", "deleted_card_id") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + column = sgqlc.types.Field("ProjectColumn", graphql_name="column") + """The column the deleted card was in.""" + + deleted_card_id = sgqlc.types.Field(ID, graphql_name="deletedCardId") + """The deleted card ID.""" + + +class DeleteProjectColumnPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "deleted_column_id", "project") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + deleted_column_id = sgqlc.types.Field(ID, graphql_name="deletedColumnId") + """The deleted column ID.""" + + project = sgqlc.types.Field("Project", graphql_name="project") + """The project the deleted column was in.""" + + +class DeleteProjectNextItemPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteProjectNextItem""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "deleted_item_id") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + deleted_item_id = sgqlc.types.Field(ID, graphql_name="deletedItemId") + """The ID of the deleted item.""" + + +class DeleteProjectPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteProject""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "owner") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + owner = sgqlc.types.Field("ProjectOwner", graphql_name="owner") + """The repository or organization the project was removed from.""" + + +class DeletePullRequestReviewCommentPayload(sgqlc.types.Type): + """Autogenerated return type of DeletePullRequestReviewComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request_review") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request_review = sgqlc.types.Field("PullRequestReview", graphql_name="pullRequestReview") + """The pull request review the deleted comment belonged to.""" + + +class DeletePullRequestReviewPayload(sgqlc.types.Type): + """Autogenerated return type of DeletePullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request_review") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request_review = sgqlc.types.Field("PullRequestReview", graphql_name="pullRequestReview") + """The deleted pull request review.""" + + +class DeleteRefPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteRef""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id",) + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteTeamDiscussionCommentPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteTeamDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id",) + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteTeamDiscussionPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteTeamDiscussion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id",) + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class DeleteVerifiableDomainPayload(sgqlc.types.Type): + """Autogenerated return type of DeleteVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "owner") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + owner = sgqlc.types.Field("VerifiableDomainOwner", graphql_name="owner") + """The owning account from which the domain was deleted.""" + + +class DependabotUpdateError(sgqlc.types.Type): + """An error produced from a Dependabot Update""" + + __schema__ = github_schema + __field_names__ = ("body", "error_type", "title") + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The body of the error""" + + error_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="errorType") + """The error code""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the error""" + + +class DeployKeyConnection(sgqlc.types.relay.Connection): + """The connection type for DeployKey.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DeployKeyEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("DeployKey"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DeployKeyEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("DeployKey", graphql_name="node") + """The item at the end of the edge.""" + + +class DeploymentConnection(sgqlc.types.relay.Connection): + """The connection type for Deployment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DeploymentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Deployment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DeploymentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Deployment", graphql_name="node") + """The item at the end of the edge.""" + + +class DeploymentProtectionRule(sgqlc.types.Type): + """A protection rule.""" + + __schema__ = github_schema + __field_names__ = ("database_id", "reviewers", "timeout", "type") + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + reviewers = sgqlc.types.Field( + sgqlc.types.non_null("DeploymentReviewerConnection"), + graphql_name="reviewers", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The teams or users that can review the deployment + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + timeout = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="timeout") + """The timeout in minutes for this protection rule.""" + + type = sgqlc.types.Field(sgqlc.types.non_null(DeploymentProtectionRuleType), graphql_name="type") + """The type of protection rule.""" + + +class DeploymentProtectionRuleConnection(sgqlc.types.relay.Connection): + """The connection type for DeploymentProtectionRule.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DeploymentProtectionRuleEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(DeploymentProtectionRule), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DeploymentProtectionRuleEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(DeploymentProtectionRule, graphql_name="node") + """The item at the end of the edge.""" + + +class DeploymentRequest(sgqlc.types.Type): + """A request to deploy a workflow run to an environment.""" + + __schema__ = github_schema + __field_names__ = ("current_user_can_approve", "environment", "reviewers", "wait_timer", "wait_timer_started_at") + current_user_can_approve = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="currentUserCanApprove") + """Whether or not the current user can approve the deployment""" + + environment = sgqlc.types.Field(sgqlc.types.non_null("Environment"), graphql_name="environment") + """The target environment of the deployment""" + + reviewers = sgqlc.types.Field( + sgqlc.types.non_null("DeploymentReviewerConnection"), + graphql_name="reviewers", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The teams or users that can review the deployment + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + wait_timer = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="waitTimer") + """The wait timer in minutes configured in the environment""" + + wait_timer_started_at = sgqlc.types.Field(DateTime, graphql_name="waitTimerStartedAt") + """The wait timer in minutes configured in the environment""" + + +class DeploymentRequestConnection(sgqlc.types.relay.Connection): + """The connection type for DeploymentRequest.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DeploymentRequestEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(DeploymentRequest), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DeploymentRequestEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(DeploymentRequest, graphql_name="node") + """The item at the end of the edge.""" + + +class DeploymentReviewConnection(sgqlc.types.relay.Connection): + """The connection type for DeploymentReview.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DeploymentReviewEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("DeploymentReview"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DeploymentReviewEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("DeploymentReview", graphql_name="node") + """The item at the end of the edge.""" + + +class DeploymentReviewerConnection(sgqlc.types.relay.Connection): + """The connection type for DeploymentReviewer.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DeploymentReviewerEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("DeploymentReviewer"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DeploymentReviewerEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("DeploymentReviewer", graphql_name="node") + """The item at the end of the edge.""" + + +class DeploymentStatusConnection(sgqlc.types.relay.Connection): + """The connection type for DeploymentStatus.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DeploymentStatusEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("DeploymentStatus"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DeploymentStatusEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("DeploymentStatus", graphql_name="node") + """The item at the end of the edge.""" + + +class DisablePullRequestAutoMergePayload(sgqlc.types.Type): + """Autogenerated return type of DisablePullRequestAutoMerge""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request auto merge was disabled on.""" + + +class DiscussionCategoryConnection(sgqlc.types.relay.Connection): + """The connection type for DiscussionCategory.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DiscussionCategoryEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("DiscussionCategory"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DiscussionCategoryEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("DiscussionCategory", graphql_name="node") + """The item at the end of the edge.""" + + +class DiscussionCommentConnection(sgqlc.types.relay.Connection): + """The connection type for DiscussionComment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DiscussionCommentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("DiscussionComment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DiscussionCommentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("DiscussionComment", graphql_name="node") + """The item at the end of the edge.""" + + +class DiscussionConnection(sgqlc.types.relay.Connection): + """The connection type for Discussion.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DiscussionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Discussion"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DiscussionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Discussion", graphql_name="node") + """The item at the end of the edge.""" + + +class DiscussionPollOptionConnection(sgqlc.types.relay.Connection): + """The connection type for DiscussionPollOption.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("DiscussionPollOptionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("DiscussionPollOption"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class DiscussionPollOptionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("DiscussionPollOption", graphql_name="node") + """The item at the end of the edge.""" + + +class DismissPullRequestReviewPayload(sgqlc.types.Type): + """Autogenerated return type of DismissPullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request_review") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request_review = sgqlc.types.Field("PullRequestReview", graphql_name="pullRequestReview") + """The dismissed pull request review.""" + + +class DismissRepositoryVulnerabilityAlertPayload(sgqlc.types.Type): + """Autogenerated return type of DismissRepositoryVulnerabilityAlert""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository_vulnerability_alert") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository_vulnerability_alert = sgqlc.types.Field("RepositoryVulnerabilityAlert", graphql_name="repositoryVulnerabilityAlert") + """The Dependabot alert that was dismissed""" + + +class EnablePullRequestAutoMergePayload(sgqlc.types.Type): + """Autogenerated return type of EnablePullRequestAutoMerge""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request auto-merge was enabled on.""" + + +class EnterpriseAdministratorConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseAdministratorEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseAdministratorEdge(sgqlc.types.Type): + """A User who is an administrator of an enterprise.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "role") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("User", graphql_name="node") + """The item at the end of the edge.""" + + role = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseAdministratorRole), graphql_name="role") + """The role of the administrator.""" + + +class EnterpriseAdministratorInvitationConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseAdministratorInvitation.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseAdministratorInvitationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseAdministratorInvitation"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseAdministratorInvitationEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseAdministratorInvitation", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseAuditEntryData(sgqlc.types.Interface): + """Metadata for an audit entry containing enterprise account + information. + """ + + __schema__ = github_schema + __field_names__ = ("enterprise_resource_path", "enterprise_slug", "enterprise_url") + enterprise_resource_path = sgqlc.types.Field(URI, graphql_name="enterpriseResourcePath") + """The HTTP path for this enterprise.""" + + enterprise_slug = sgqlc.types.Field(String, graphql_name="enterpriseSlug") + """The slug of the enterprise.""" + + enterprise_url = sgqlc.types.Field(URI, graphql_name="enterpriseUrl") + """The HTTP URL for this enterprise.""" + + +class EnterpriseBillingInfo(sgqlc.types.Type): + """Enterprise billing information visible to enterprise billing + managers and owners. + """ + + __schema__ = github_schema + __field_names__ = ( + "all_licensable_users_count", + "asset_packs", + "bandwidth_quota", + "bandwidth_usage", + "bandwidth_usage_percentage", + "storage_quota", + "storage_usage", + "storage_usage_percentage", + "total_available_licenses", + "total_licenses", + ) + all_licensable_users_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="allLicensableUsersCount") + """The number of licenseable users/emails across the enterprise.""" + + asset_packs = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="assetPacks") + """The number of data packs used by all organizations owned by the + enterprise. + """ + + bandwidth_quota = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="bandwidthQuota") + """The bandwidth quota in GB for all organizations owned by the + enterprise. + """ + + bandwidth_usage = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="bandwidthUsage") + """The bandwidth usage in GB for all organizations owned by the + enterprise. + """ + + bandwidth_usage_percentage = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="bandwidthUsagePercentage") + """The bandwidth usage as a percentage of the bandwidth quota.""" + + storage_quota = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="storageQuota") + """The storage quota in GB for all organizations owned by the + enterprise. + """ + + storage_usage = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="storageUsage") + """The storage usage in GB for all organizations owned by the + enterprise. + """ + + storage_usage_percentage = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="storageUsagePercentage") + """The storage usage as a percentage of the storage quota.""" + + total_available_licenses = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalAvailableLicenses") + """The number of available licenses across all owned organizations + based on the unique number of billable users. + """ + + total_licenses = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalLicenses") + """The total number of licenses allocated.""" + + +class EnterpriseMemberConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseMember.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseMemberEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseMember"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseMemberEdge(sgqlc.types.Type): + """A User who is a member of an enterprise through one or more + organizations. + """ + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseMember", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseOrganizationMembershipConnection(sgqlc.types.relay.Connection): + """The connection type for Organization.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseOrganizationMembershipEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Organization"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseOrganizationMembershipEdge(sgqlc.types.Type): + """An enterprise organization that a user is a member of.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "role") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Organization", graphql_name="node") + """The item at the end of the edge.""" + + role = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseUserAccountMembershipRole), graphql_name="role") + """The role of the user in the enterprise membership.""" + + +class EnterpriseOutsideCollaboratorConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseOutsideCollaboratorEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseOutsideCollaboratorEdge(sgqlc.types.Type): + """A User who is an outside collaborator of an enterprise through one + or more organizations. + """ + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "repositories") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("User", graphql_name="node") + """The item at the end of the edge.""" + + repositories = sgqlc.types.Field( + sgqlc.types.non_null("EnterpriseRepositoryInfoConnection"), + graphql_name="repositories", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(RepositoryOrder, graphql_name="orderBy", default={"field": "NAME", "direction": "ASC"})), + ) + ), + ) + """The enterprise organization repositories this user is a member of. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`RepositoryOrder`): Ordering options for + repositories. (default: `{field: NAME, direction: ASC}`) + """ + + +class EnterpriseOwnerInfo(sgqlc.types.Type): + """Enterprise information only visible to enterprise owners.""" + + __schema__ = github_schema + __field_names__ = ( + "admins", + "affiliated_users_with_two_factor_disabled", + "affiliated_users_with_two_factor_disabled_exist", + "allow_private_repository_forking_setting", + "allow_private_repository_forking_setting_organizations", + "default_repository_permission_setting", + "default_repository_permission_setting_organizations", + "domains", + "enterprise_server_installations", + "ip_allow_list_enabled_setting", + "ip_allow_list_entries", + "ip_allow_list_for_installed_apps_enabled_setting", + "is_updating_default_repository_permission", + "is_updating_two_factor_requirement", + "members_can_change_repository_visibility_setting", + "members_can_change_repository_visibility_setting_organizations", + "members_can_create_internal_repositories_setting", + "members_can_create_private_repositories_setting", + "members_can_create_public_repositories_setting", + "members_can_create_repositories_setting", + "members_can_create_repositories_setting_organizations", + "members_can_delete_issues_setting", + "members_can_delete_issues_setting_organizations", + "members_can_delete_repositories_setting", + "members_can_delete_repositories_setting_organizations", + "members_can_invite_collaborators_setting", + "members_can_invite_collaborators_setting_organizations", + "members_can_make_purchases_setting", + "members_can_update_protected_branches_setting", + "members_can_update_protected_branches_setting_organizations", + "members_can_view_dependency_insights_setting", + "members_can_view_dependency_insights_setting_organizations", + "notification_delivery_restriction_enabled_setting", + "oidc_provider", + "organization_projects_setting", + "organization_projects_setting_organizations", + "outside_collaborators", + "pending_admin_invitations", + "pending_collaborator_invitations", + "pending_member_invitations", + "repository_projects_setting", + "repository_projects_setting_organizations", + "saml_identity_provider", + "saml_identity_provider_setting_organizations", + "support_entitlements", + "team_discussions_setting", + "team_discussions_setting_organizations", + "two_factor_required_setting", + "two_factor_required_setting_organizations", + ) + admins = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseAdministratorConnection), + graphql_name="admins", + args=sgqlc.types.ArgDict( + ( + ( + "organization_logins", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="organizationLogins", default=None), + ), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("role", sgqlc.types.Arg(EnterpriseAdministratorRole, graphql_name="role", default=None)), + ( + "order_by", + sgqlc.types.Arg(EnterpriseMemberOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"}), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of all of the administrators for this enterprise. + + Arguments: + + * `organization_logins` (`[String!]`): Only return members within + the organizations with these logins + * `query` (`String`): The search string to look for. + * `role` (`EnterpriseAdministratorRole`): The role to filter by. + * `order_by` (`EnterpriseMemberOrder`): Ordering options for + administrators returned from the connection. (default: `{field: + LOGIN, direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + affiliated_users_with_two_factor_disabled = sgqlc.types.Field( + sgqlc.types.non_null("UserConnection"), + graphql_name="affiliatedUsersWithTwoFactorDisabled", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users in the enterprise who currently have two-factor + authentication disabled. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + affiliated_users_with_two_factor_disabled_exist = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="affiliatedUsersWithTwoFactorDisabledExist" + ) + """Whether or not affiliated users with two-factor authentication + disabled exist in the enterprise. + """ + + allow_private_repository_forking_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="allowPrivateRepositoryForkingSetting" + ) + """The setting value for whether private repository forking is + enabled for repositories in organizations in this enterprise. + """ + + allow_private_repository_forking_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="allowPrivateRepositoryForkingSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + private repository forking setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + default_repository_permission_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseDefaultRepositoryPermissionSettingValue), graphql_name="defaultRepositoryPermissionSetting" + ) + """The setting value for base repository permissions for + organizations in this enterprise. + """ + + default_repository_permission_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="defaultRepositoryPermissionSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(DefaultRepositoryPermissionField), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + base repository permission. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`DefaultRepositoryPermissionField!`): The permission to + find organizations for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + domains = sgqlc.types.Field( + sgqlc.types.non_null("VerifiableDomainConnection"), + graphql_name="domains", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("is_verified", sgqlc.types.Arg(Boolean, graphql_name="isVerified", default=None)), + ("is_approved", sgqlc.types.Arg(Boolean, graphql_name="isApproved", default=None)), + ( + "order_by", + sgqlc.types.Arg(VerifiableDomainOrder, graphql_name="orderBy", default={"field": "DOMAIN", "direction": "ASC"}), + ), + ) + ), + ) + """A list of domains owned by the enterprise. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `is_verified` (`Boolean`): Filter whether or not the domain is + verified. (default: `null`) + * `is_approved` (`Boolean`): Filter whether or not the domain is + approved. (default: `null`) + * `order_by` (`VerifiableDomainOrder`): Ordering options for + verifiable domains returned. (default: `{field: DOMAIN, + direction: ASC}`) + """ + + enterprise_server_installations = sgqlc.types.Field( + sgqlc.types.non_null("EnterpriseServerInstallationConnection"), + graphql_name="enterpriseServerInstallations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("connected_only", sgqlc.types.Arg(Boolean, graphql_name="connectedOnly", default=False)), + ( + "order_by", + sgqlc.types.Arg( + EnterpriseServerInstallationOrder, graphql_name="orderBy", default={"field": "HOST_NAME", "direction": "ASC"} + ), + ), + ) + ), + ) + """Enterprise Server installations owned by the enterprise. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `connected_only` (`Boolean`): Whether or not to only return + installations discovered via GitHub Connect. (default: `false`) + * `order_by` (`EnterpriseServerInstallationOrder`): Ordering + options for Enterprise Server installations returned. (default: + `{field: HOST_NAME, direction: ASC}`) + """ + + ip_allow_list_enabled_setting = sgqlc.types.Field( + sgqlc.types.non_null(IpAllowListEnabledSettingValue), graphql_name="ipAllowListEnabledSetting" + ) + """The setting value for whether the enterprise has an IP allow list + enabled. + """ + + ip_allow_list_entries = sgqlc.types.Field( + sgqlc.types.non_null("IpAllowListEntryConnection"), + graphql_name="ipAllowListEntries", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg( + IpAllowListEntryOrder, graphql_name="orderBy", default={"field": "ALLOW_LIST_VALUE", "direction": "ASC"} + ), + ), + ) + ), + ) + """The IP addresses that are allowed to access resources owned by the + enterprise. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`IpAllowListEntryOrder`): Ordering options for IP + allow list entries returned. (default: `{field: + ALLOW_LIST_VALUE, direction: ASC}`) + """ + + ip_allow_list_for_installed_apps_enabled_setting = sgqlc.types.Field( + sgqlc.types.non_null(IpAllowListForInstalledAppsEnabledSettingValue), graphql_name="ipAllowListForInstalledAppsEnabledSetting" + ) + """The setting value for whether the enterprise has IP allow list + configuration for installed GitHub Apps enabled. + """ + + is_updating_default_repository_permission = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isUpdatingDefaultRepositoryPermission" + ) + """Whether or not the base repository permission is currently being + updated. + """ + + is_updating_two_factor_requirement = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isUpdatingTwoFactorRequirement") + """Whether the two-factor authentication requirement is currently + being enforced. + """ + + members_can_change_repository_visibility_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="membersCanChangeRepositoryVisibilitySetting" + ) + """The setting value for whether organization members with admin + permissions on a repository can change repository visibility. + """ + + members_can_change_repository_visibility_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="membersCanChangeRepositoryVisibilitySettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + can change repository visibility setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + members_can_create_internal_repositories_setting = sgqlc.types.Field( + Boolean, graphql_name="membersCanCreateInternalRepositoriesSetting" + ) + """The setting value for whether members of organizations in the + enterprise can create internal repositories. + """ + + members_can_create_private_repositories_setting = sgqlc.types.Field(Boolean, graphql_name="membersCanCreatePrivateRepositoriesSetting") + """The setting value for whether members of organizations in the + enterprise can create private repositories. + """ + + members_can_create_public_repositories_setting = sgqlc.types.Field(Boolean, graphql_name="membersCanCreatePublicRepositoriesSetting") + """The setting value for whether members of organizations in the + enterprise can create public repositories. + """ + + members_can_create_repositories_setting = sgqlc.types.Field( + EnterpriseMembersCanCreateRepositoriesSettingValue, graphql_name="membersCanCreateRepositoriesSetting" + ) + """The setting value for whether members of organizations in the + enterprise can create repositories. + """ + + members_can_create_repositories_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="membersCanCreateRepositoriesSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "value", + sgqlc.types.Arg( + sgqlc.types.non_null(OrganizationMembersCanCreateRepositoriesSettingValue), graphql_name="value", default=None + ), + ), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + repository creation setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` + (`OrganizationMembersCanCreateRepositoriesSettingValue!`): The + setting to find organizations for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + members_can_delete_issues_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="membersCanDeleteIssuesSetting" + ) + """The setting value for whether members with admin permissions for + repositories can delete issues. + """ + + members_can_delete_issues_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="membersCanDeleteIssuesSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + members can delete issues setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + members_can_delete_repositories_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="membersCanDeleteRepositoriesSetting" + ) + """The setting value for whether members with admin permissions for + repositories can delete or transfer repositories. + """ + + members_can_delete_repositories_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="membersCanDeleteRepositoriesSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + members can delete repositories setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + members_can_invite_collaborators_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="membersCanInviteCollaboratorsSetting" + ) + """The setting value for whether members of organizations in the + enterprise can invite outside collaborators. + """ + + members_can_invite_collaborators_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="membersCanInviteCollaboratorsSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + members can invite collaborators setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + members_can_make_purchases_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseMembersCanMakePurchasesSettingValue), graphql_name="membersCanMakePurchasesSetting" + ) + """Indicates whether members of this enterprise's organizations can + purchase additional services for those organizations. + """ + + members_can_update_protected_branches_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="membersCanUpdateProtectedBranchesSetting" + ) + """The setting value for whether members with admin permissions for + repositories can update protected branches. + """ + + members_can_update_protected_branches_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="membersCanUpdateProtectedBranchesSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + members can update protected branches setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + members_can_view_dependency_insights_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="membersCanViewDependencyInsightsSetting" + ) + """The setting value for whether members can view dependency + insights. + """ + + members_can_view_dependency_insights_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="membersCanViewDependencyInsightsSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + members can view dependency insights setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + notification_delivery_restriction_enabled_setting = sgqlc.types.Field( + sgqlc.types.non_null(NotificationRestrictionSettingValue), graphql_name="notificationDeliveryRestrictionEnabledSetting" + ) + """Indicates if email notification delivery for this enterprise is + restricted to verified or approved domains. + """ + + oidc_provider = sgqlc.types.Field("OIDCProvider", graphql_name="oidcProvider") + """The OIDC Identity Provider for the enterprise.""" + + organization_projects_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="organizationProjectsSetting" + ) + """The setting value for whether organization projects are enabled + for organizations in this enterprise. + """ + + organization_projects_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="organizationProjectsSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + organization projects setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + outside_collaborators = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseOutsideCollaboratorConnection), + graphql_name="outsideCollaborators", + args=sgqlc.types.ArgDict( + ( + ("login", sgqlc.types.Arg(String, graphql_name="login", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ( + "order_by", + sgqlc.types.Arg(EnterpriseMemberOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"}), + ), + ("visibility", sgqlc.types.Arg(RepositoryVisibility, graphql_name="visibility", default=None)), + ("has_two_factor_enabled", sgqlc.types.Arg(Boolean, graphql_name="hasTwoFactorEnabled", default=None)), + ( + "organization_logins", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="organizationLogins", default=None), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of outside collaborators across the repositories in the + enterprise. + + Arguments: + + * `login` (`String`): The login of one specific outside + collaborator. + * `query` (`String`): The search string to look for. + * `order_by` (`EnterpriseMemberOrder`): Ordering options for + outside collaborators returned from the connection. (default: + `{field: LOGIN, direction: ASC}`) + * `visibility` (`RepositoryVisibility`): Only return outside + collaborators on repositories with this visibility. + * `has_two_factor_enabled` (`Boolean`): Only return outside + collaborators with this two-factor authentication status. + (default: `null`) + * `organization_logins` (`[String!]`): Only return outside + collaborators within the organizations with these logins + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pending_admin_invitations = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseAdministratorInvitationConnection), + graphql_name="pendingAdminInvitations", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ( + "order_by", + sgqlc.types.Arg( + EnterpriseAdministratorInvitationOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "DESC"} + ), + ), + ("role", sgqlc.types.Arg(EnterpriseAdministratorRole, graphql_name="role", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pending administrator invitations for the enterprise. + + Arguments: + + * `query` (`String`): The search string to look for. + * `order_by` (`EnterpriseAdministratorInvitationOrder`): Ordering + options for pending enterprise administrator invitations + returned from the connection. (default: `{field: CREATED_AT, + direction: DESC}`) + * `role` (`EnterpriseAdministratorRole`): The role to filter by. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pending_collaborator_invitations = sgqlc.types.Field( + sgqlc.types.non_null("RepositoryInvitationConnection"), + graphql_name="pendingCollaboratorInvitations", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ( + "order_by", + sgqlc.types.Arg( + RepositoryInvitationOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "DESC"} + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pending collaborator invitations across the repositories + in the enterprise. + + Arguments: + + * `query` (`String`): The search string to look for. + * `order_by` (`RepositoryInvitationOrder`): Ordering options for + pending repository collaborator invitations returned from the + connection. (default: `{field: CREATED_AT, direction: DESC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pending_member_invitations = sgqlc.types.Field( + sgqlc.types.non_null("EnterprisePendingMemberInvitationConnection"), + graphql_name="pendingMemberInvitations", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ( + "organization_logins", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="organizationLogins", default=None), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pending member invitations for organizations in the + enterprise. + + Arguments: + + * `query` (`String`): The search string to look for. + * `organization_logins` (`[String!]`): Only return invitations + within the organizations with these logins + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + repository_projects_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="repositoryProjectsSetting" + ) + """The setting value for whether repository projects are enabled in + this enterprise. + """ + + repository_projects_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="repositoryProjectsSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + repository projects setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + saml_identity_provider = sgqlc.types.Field("EnterpriseIdentityProvider", graphql_name="samlIdentityProvider") + """The SAML Identity Provider for the enterprise. When used by a + GitHub App, requires an installation token with read and write + access to members. + """ + + saml_identity_provider_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="samlIdentityProviderSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(IdentityProviderConfigurationState), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the SAML single + sign-on setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`IdentityProviderConfigurationState!`): The setting + value to find organizations for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + support_entitlements = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseMemberConnection), + graphql_name="supportEntitlements", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg(EnterpriseMemberOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"}), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of members with a support entitlement. + + Arguments: + + * `order_by` (`EnterpriseMemberOrder`): Ordering options for + support entitlement users returned from the connection. + (default: `{field: LOGIN, direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + team_discussions_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledDisabledSettingValue), graphql_name="teamDiscussionsSetting" + ) + """The setting value for whether team discussions are enabled for + organizations in this enterprise. + """ + + team_discussions_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="teamDiscussionsSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the provided + team discussions setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + two_factor_required_setting = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseEnabledSettingValue), graphql_name="twoFactorRequiredSetting" + ) + """The setting value for whether the enterprise requires two-factor + authentication for its organizations and users. + """ + + two_factor_required_setting_organizations = sgqlc.types.Field( + sgqlc.types.non_null("OrganizationConnection"), + graphql_name="twoFactorRequiredSettingOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("value", sgqlc.types.Arg(sgqlc.types.non_null(Boolean), graphql_name="value", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ) + ), + ) + """A list of enterprise organizations configured with the two-factor + authentication setting value. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `value` (`Boolean!`): The setting value to find organizations + for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations with this setting. (default: `{field: LOGIN, + direction: ASC}`) + """ + + +class EnterprisePendingMemberInvitationConnection(sgqlc.types.relay.Connection): + """The connection type for OrganizationInvitation.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count", "total_unique_user_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterprisePendingMemberInvitationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("OrganizationInvitation"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + total_unique_user_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalUniqueUserCount") + """Identifies the total count of unique users in the connection.""" + + +class EnterprisePendingMemberInvitationEdge(sgqlc.types.Type): + """An invitation to be a member in an enterprise organization.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("OrganizationInvitation", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseRepositoryInfoConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseRepositoryInfo.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseRepositoryInfoEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseRepositoryInfo"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseRepositoryInfoEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseRepositoryInfo", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseServerInstallationConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseServerInstallation.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerInstallationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerInstallation"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseServerInstallationEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseServerInstallation", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseServerUserAccountConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseServerUserAccount.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerUserAccountEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerUserAccount"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseServerUserAccountEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseServerUserAccount", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseServerUserAccountEmailConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseServerUserAccountEmail.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerUserAccountEmailEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerUserAccountEmail"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseServerUserAccountEmailEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseServerUserAccountEmail", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseServerUserAccountsUploadConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseServerUserAccountsUpload.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerUserAccountsUploadEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseServerUserAccountsUpload"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseServerUserAccountsUploadEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseServerUserAccountsUpload", graphql_name="node") + """The item at the end of the edge.""" + + +class EnterpriseUserAccountConnection(sgqlc.types.relay.Connection): + """The connection type for EnterpriseUserAccount.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseUserAccountEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("EnterpriseUserAccount"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnterpriseUserAccountEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("EnterpriseUserAccount", graphql_name="node") + """The item at the end of the edge.""" + + +class EnvironmentConnection(sgqlc.types.relay.Connection): + """The connection type for Environment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("EnvironmentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Environment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class EnvironmentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Environment", graphql_name="node") + """The item at the end of the edge.""" + + +class ExternalIdentityAttribute(sgqlc.types.Type): + """An attribute for the External Identity attributes collection""" + + __schema__ = github_schema + __field_names__ = ("metadata", "name", "value") + metadata = sgqlc.types.Field(String, graphql_name="metadata") + """The attribute metadata as JSON""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The attribute name""" + + value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value") + """The attribute value""" + + +class ExternalIdentityConnection(sgqlc.types.relay.Connection): + """The connection type for ExternalIdentity.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ExternalIdentityEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ExternalIdentity"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ExternalIdentityEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ExternalIdentity", graphql_name="node") + """The item at the end of the edge.""" + + +class ExternalIdentitySamlAttributes(sgqlc.types.Type): + """SAML attributes for the External Identity""" + + __schema__ = github_schema + __field_names__ = ("attributes", "emails", "family_name", "given_name", "groups", "name_id", "username") + attributes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ExternalIdentityAttribute))), graphql_name="attributes" + ) + """SAML Identity attributes""" + + emails = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("UserEmailMetadata")), graphql_name="emails") + """The emails associated with the SAML identity""" + + family_name = sgqlc.types.Field(String, graphql_name="familyName") + """Family name of the SAML identity""" + + given_name = sgqlc.types.Field(String, graphql_name="givenName") + """Given name of the SAML identity""" + + groups = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="groups") + """The groups linked to this identity in IDP""" + + name_id = sgqlc.types.Field(String, graphql_name="nameId") + """The NameID of the SAML identity""" + + username = sgqlc.types.Field(String, graphql_name="username") + """The userName of the SAML identity""" + + +class ExternalIdentityScimAttributes(sgqlc.types.Type): + """SCIM attributes for the External Identity""" + + __schema__ = github_schema + __field_names__ = ("emails", "family_name", "given_name", "groups", "username") + emails = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("UserEmailMetadata")), graphql_name="emails") + """The emails associated with the SCIM identity""" + + family_name = sgqlc.types.Field(String, graphql_name="familyName") + """Family name of the SCIM identity""" + + given_name = sgqlc.types.Field(String, graphql_name="givenName") + """Given name of the SCIM identity""" + + groups = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="groups") + """The groups linked to this identity in IDP""" + + username = sgqlc.types.Field(String, graphql_name="username") + """The userName of the SCIM identity""" + + +class FollowOrganizationPayload(sgqlc.types.Type): + """Autogenerated return type of FollowOrganization""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "organization") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + organization = sgqlc.types.Field("Organization", graphql_name="organization") + """The organization that was followed.""" + + +class FollowUserPayload(sgqlc.types.Type): + """Autogenerated return type of FollowUser""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "user") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + user = sgqlc.types.Field("User", graphql_name="user") + """The user that was followed.""" + + +class FollowerConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("UserEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class FollowingConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("UserEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class FundingLink(sgqlc.types.Type): + """A funding platform link for a repository.""" + + __schema__ = github_schema + __field_names__ = ("platform", "url") + platform = sgqlc.types.Field(sgqlc.types.non_null(FundingPlatform), graphql_name="platform") + """The funding platform this link is for.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The configured URL for this funding link.""" + + +class GistCommentConnection(sgqlc.types.relay.Connection): + """The connection type for GistComment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("GistCommentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("GistComment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class GistCommentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("GistComment", graphql_name="node") + """The item at the end of the edge.""" + + +class GistConnection(sgqlc.types.relay.Connection): + """The connection type for Gist.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("GistEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Gist"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class GistEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Gist", graphql_name="node") + """The item at the end of the edge.""" + + +class GistFile(sgqlc.types.Type): + """A file in a gist.""" + + __schema__ = github_schema + __field_names__ = ("encoded_name", "encoding", "extension", "is_image", "is_truncated", "language", "name", "size", "text") + encoded_name = sgqlc.types.Field(String, graphql_name="encodedName") + """The file name encoded to remove characters that are invalid in URL + paths. + """ + + encoding = sgqlc.types.Field(String, graphql_name="encoding") + """The gist file encoding.""" + + extension = sgqlc.types.Field(String, graphql_name="extension") + """The file extension from the file name.""" + + is_image = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isImage") + """Indicates if this file is an image.""" + + is_truncated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isTruncated") + """Whether the file's contents were truncated.""" + + language = sgqlc.types.Field("Language", graphql_name="language") + """The programming language this file is written in.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The gist file name.""" + + size = sgqlc.types.Field(Int, graphql_name="size") + """The gist file size in bytes.""" + + text = sgqlc.types.Field( + String, graphql_name="text", args=sgqlc.types.ArgDict((("truncate", sgqlc.types.Arg(Int, graphql_name="truncate", default=None)),)) + ) + """UTF8 text data or null if the file is binary + + Arguments: + + * `truncate` (`Int`): Optionally truncate the returned file to + this length. + """ + + +class GitActor(sgqlc.types.Type): + """Represents an actor in a Git commit (ie. an author or committer).""" + + __schema__ = github_schema + __field_names__ = ("avatar_url", "date", "email", "name", "user") + avatar_url = sgqlc.types.Field( + sgqlc.types.non_null(URI), + graphql_name="avatarUrl", + args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=None)),)), + ) + """A URL pointing to the author's public avatar. + + Arguments: + + * `size` (`Int`): The size of the resulting square image. + """ + + date = sgqlc.types.Field(GitTimestamp, graphql_name="date") + """The timestamp of the Git action (authoring or committing).""" + + email = sgqlc.types.Field(String, graphql_name="email") + """The email in the Git commit.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The name in the Git commit.""" + + user = sgqlc.types.Field("User", graphql_name="user") + """The GitHub user corresponding to the email field. Null if no such + user exists. + """ + + +class GitActorConnection(sgqlc.types.relay.Connection): + """The connection type for GitActor.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("GitActorEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(GitActor), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class GitActorEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(GitActor, graphql_name="node") + """The item at the end of the edge.""" + + +class GitHubMetadata(sgqlc.types.Type): + """Represents information about the GitHub instance.""" + + __schema__ = github_schema + __field_names__ = ( + "git_hub_services_sha", + "git_ip_addresses", + "hook_ip_addresses", + "importer_ip_addresses", + "is_password_authentication_verifiable", + "pages_ip_addresses", + ) + git_hub_services_sha = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="gitHubServicesSha") + """Returns a String that's a SHA of `github-services`""" + + git_ip_addresses = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="gitIpAddresses") + """IP addresses that users connect to for git operations""" + + hook_ip_addresses = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="hookIpAddresses") + """IP addresses that service hooks are sent from""" + + importer_ip_addresses = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="importerIpAddresses") + """IP addresses that the importer connects from""" + + is_password_authentication_verifiable = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isPasswordAuthenticationVerifiable" + ) + """Whether or not users are verified""" + + pages_ip_addresses = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="pagesIpAddresses") + """IP addresses for GitHub Pages' A records""" + + +class GitObject(sgqlc.types.Interface): + """Represents a Git object.""" + + __schema__ = github_schema + __field_names__ = ("abbreviated_oid", "commit_resource_path", "commit_url", "id", "oid", "repository") + abbreviated_oid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="abbreviatedOid") + """An abbreviated version of the Git object ID""" + + commit_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="commitResourcePath") + """The HTTP path for this Git object""" + + commit_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="commitUrl") + """The HTTP URL for this Git object""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + oid = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="oid") + """The Git object ID""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The Repository the Git object belongs to""" + + +class GitSignature(sgqlc.types.Interface): + """Information about a signature (GPG or S/MIME) on a Commit or Tag.""" + + __schema__ = github_schema + __field_names__ = ("email", "is_valid", "payload", "signature", "signer", "state", "was_signed_by_git_hub") + email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email") + """Email used to sign this object.""" + + is_valid = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isValid") + """True if the signature is valid and verified by GitHub.""" + + payload = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="payload") + """Payload for GPG signing object. Raw ODB object without the + signature header. + """ + + signature = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="signature") + """ASCII-armored signature header from object.""" + + signer = sgqlc.types.Field("User", graphql_name="signer") + """GitHub user corresponding to the email signing this commit.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(GitSignatureState), graphql_name="state") + """The state of this signature. `VALID` if signature is valid and + verified by GitHub, otherwise represents reason why signature is + considered invalid. + """ + + was_signed_by_git_hub = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="wasSignedByGitHub") + """True if the signature was made with GitHub's signing key.""" + + +class GrantEnterpriseOrganizationsMigratorRolePayload(sgqlc.types.Type): + """Autogenerated return type of + GrantEnterpriseOrganizationsMigratorRole + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "organizations") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + organizations = sgqlc.types.Field( + "OrganizationConnection", + graphql_name="organizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The organizations that had the migrator role applied to for the + given user. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class GrantMigratorRolePayload(sgqlc.types.Type): + """Autogenerated return type of GrantMigratorRole""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "success") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + success = sgqlc.types.Field(Boolean, graphql_name="success") + """Did the operation succeed?""" + + +class Hovercard(sgqlc.types.Type): + """Detail needed to display a hovercard for a user""" + + __schema__ = github_schema + __field_names__ = ("contexts",) + contexts = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("HovercardContext"))), graphql_name="contexts" + ) + """Each of the contexts for this hovercard""" + + +class HovercardContext(sgqlc.types.Interface): + """An individual line of a hovercard""" + + __schema__ = github_schema + __field_names__ = ("message", "octicon") + message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message") + """A string describing this context""" + + octicon = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="octicon") + """An octicon to accompany this context""" + + +class InviteEnterpriseAdminPayload(sgqlc.types.Type): + """Autogenerated return type of InviteEnterpriseAdmin""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "invitation") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + invitation = sgqlc.types.Field("EnterpriseAdministratorInvitation", graphql_name="invitation") + """The created enterprise administrator invitation.""" + + +class IpAllowListEntryConnection(sgqlc.types.relay.Connection): + """The connection type for IpAllowListEntry.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("IpAllowListEntryEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("IpAllowListEntry"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class IpAllowListEntryEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("IpAllowListEntry", graphql_name="node") + """The item at the end of the edge.""" + + +class IssueCommentConnection(sgqlc.types.relay.Connection): + """The connection type for IssueComment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("IssueCommentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("IssueComment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class IssueCommentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("IssueComment", graphql_name="node") + """The item at the end of the edge.""" + + +class IssueConnection(sgqlc.types.relay.Connection): + """The connection type for Issue.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("IssueEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Issue"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class IssueContributionsByRepository(sgqlc.types.Type): + """This aggregates issues opened by a user within one repository.""" + + __schema__ = github_schema + __field_names__ = ("contributions", "repository") + contributions = sgqlc.types.Field( + sgqlc.types.non_null(CreatedIssueContributionConnection), + graphql_name="contributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(ContributionOrder, graphql_name="orderBy", default={"direction": "DESC"})), + ) + ), + ) + """The issue contributions. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`ContributionOrder`): Ordering options for + contributions returned from the connection. (default: + `{direction: DESC}`) + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository in which the issues were opened.""" + + +class IssueEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Issue", graphql_name="node") + """The item at the end of the edge.""" + + +class IssueTemplate(sgqlc.types.Type): + """A repository issue template.""" + + __schema__ = github_schema + __field_names__ = ("about", "body", "name", "title") + about = sgqlc.types.Field(String, graphql_name="about") + """The template purpose.""" + + body = sgqlc.types.Field(String, graphql_name="body") + """The suggested issue body.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The template name.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The suggested issue title.""" + + +class IssueTimelineConnection(sgqlc.types.relay.Connection): + """The connection type for IssueTimelineItem.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("IssueTimelineItemEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("IssueTimelineItem"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class IssueTimelineItemEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("IssueTimelineItem", graphql_name="node") + """The item at the end of the edge.""" + + +class IssueTimelineItemsConnection(sgqlc.types.relay.Connection): + """The connection type for IssueTimelineItems.""" + + __schema__ = github_schema + __field_names__ = ("edges", "filtered_count", "nodes", "page_count", "page_info", "total_count", "updated_at") + edges = sgqlc.types.Field(sgqlc.types.list_of("IssueTimelineItemsEdge"), graphql_name="edges") + """A list of edges.""" + + filtered_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="filteredCount") + """Identifies the count of items after applying `before` and `after` + filters. + """ + + nodes = sgqlc.types.Field(sgqlc.types.list_of("IssueTimelineItems"), graphql_name="nodes") + """A list of nodes.""" + + page_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="pageCount") + """Identifies the count of items after applying `before`/`after` + filters and `first`/`last`/`skip` slicing. + """ + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the timeline was last updated.""" + + +class IssueTimelineItemsEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("IssueTimelineItems", graphql_name="node") + """The item at the end of the edge.""" + + +class LabelConnection(sgqlc.types.relay.Connection): + """The connection type for Label.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("LabelEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Label"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class LabelEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Label", graphql_name="node") + """The item at the end of the edge.""" + + +class Labelable(sgqlc.types.Interface): + """An object that can have labels assigned to it.""" + + __schema__ = github_schema + __field_names__ = ("labels",) + labels = sgqlc.types.Field( + LabelConnection, + graphql_name="labels", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(LabelOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "ASC"})), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of labels associated with the object. + + Arguments: + + * `order_by` (`LabelOrder`): Ordering options for labels returned + from the connection. (default: `{field: CREATED_AT, direction: + ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class LanguageConnection(sgqlc.types.relay.Connection): + """A list of languages associated with the parent.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count", "total_size") + edges = sgqlc.types.Field(sgqlc.types.list_of("LanguageEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Language"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + total_size = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalSize") + """The total size in bytes of files written in that language.""" + + +class LanguageEdge(sgqlc.types.Type): + """Represents the language of a repository.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "size") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + + node = sgqlc.types.Field(sgqlc.types.non_null("Language"), graphql_name="node") + + size = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="size") + """The number of bytes of code written in the language.""" + + +class LicenseRule(sgqlc.types.Type): + """Describes a License's conditions, permissions, and limitations""" + + __schema__ = github_schema + __field_names__ = ("description", "key", "label") + description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description") + """A description of the rule""" + + key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key") + """The machine-readable rule key""" + + label = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="label") + """The human-readable rule label""" + + +class LinkRepositoryToProjectPayload(sgqlc.types.Type): + """Autogenerated return type of LinkRepositoryToProject""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project = sgqlc.types.Field("Project", graphql_name="project") + """The linked Project.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The linked Repository.""" + + +class LockLockablePayload(sgqlc.types.Type): + """Autogenerated return type of LockLockable""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "locked_record") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + locked_record = sgqlc.types.Field("Lockable", graphql_name="lockedRecord") + """The item that was locked.""" + + +class Lockable(sgqlc.types.Interface): + """An object that can be locked.""" + + __schema__ = github_schema + __field_names__ = ("active_lock_reason", "locked") + active_lock_reason = sgqlc.types.Field(LockReason, graphql_name="activeLockReason") + """Reason that the conversation was locked.""" + + locked = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="locked") + """`true` if the object is locked""" + + +class MarkDiscussionCommentAsAnswerPayload(sgqlc.types.Type): + """Autogenerated return type of MarkDiscussionCommentAsAnswer""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "discussion") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + discussion = sgqlc.types.Field("Discussion", graphql_name="discussion") + """The discussion that includes the chosen comment.""" + + +class MarkFileAsViewedPayload(sgqlc.types.Type): + """Autogenerated return type of MarkFileAsViewed""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The updated pull request.""" + + +class MarkPullRequestReadyForReviewPayload(sgqlc.types.Type): + """Autogenerated return type of MarkPullRequestReadyForReview""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request that is ready for review.""" + + +class MarketplaceListingConnection(sgqlc.types.relay.Connection): + """Look up Marketplace Listings""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("MarketplaceListingEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("MarketplaceListing"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class MarketplaceListingEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("MarketplaceListing", graphql_name="node") + """The item at the end of the edge.""" + + +class MemberStatusable(sgqlc.types.Interface): + """Entities that have members who can set status messages.""" + + __schema__ = github_schema + __field_names__ = ("member_statuses",) + member_statuses = sgqlc.types.Field( + sgqlc.types.non_null("UserStatusConnection"), + graphql_name="memberStatuses", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg(UserStatusOrder, graphql_name="orderBy", default={"field": "UPDATED_AT", "direction": "DESC"}), + ), + ) + ), + ) + """Get the status messages members of this entity have set that are + either public or visible only to the organization. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`UserStatusOrder`): Ordering options for user + statuses returned from the connection. (default: `{field: + UPDATED_AT, direction: DESC}`) + """ + + +class MergeBranchPayload(sgqlc.types.Type): + """Autogenerated return type of MergeBranch""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "merge_commit") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + merge_commit = sgqlc.types.Field("Commit", graphql_name="mergeCommit") + """The resulting merge Commit.""" + + +class MergePullRequestPayload(sgqlc.types.Type): + """Autogenerated return type of MergePullRequest""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request that was merged.""" + + +class Migration(sgqlc.types.Interface): + """Represents an Octoshift migration.""" + + __schema__ = github_schema + __field_names__ = ( + "continue_on_error", + "created_at", + "failure_reason", + "id", + "migration_log_url", + "migration_source", + "repository_name", + "source_url", + "state", + ) + continue_on_error = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="continueOnError") + """The Octoshift migration flag to continue on error.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + failure_reason = sgqlc.types.Field(String, graphql_name="failureReason") + """The reason the migration failed.""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + migration_log_url = sgqlc.types.Field(URI, graphql_name="migrationLogUrl") + """The URL for the migration log (expires 1 day after migration + completes). + """ + + migration_source = sgqlc.types.Field(sgqlc.types.non_null("MigrationSource"), graphql_name="migrationSource") + """The Octoshift migration source.""" + + repository_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="repositoryName") + """The target repository name.""" + + source_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="sourceUrl") + """The Octoshift migration source URL.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(MigrationState), graphql_name="state") + """The Octoshift migration state.""" + + +class MilestoneConnection(sgqlc.types.relay.Connection): + """The connection type for Milestone.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("MilestoneEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Milestone"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class MilestoneEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Milestone", graphql_name="node") + """The item at the end of the edge.""" + + +class Minimizable(sgqlc.types.Interface): + """Entities that can be minimized.""" + + __schema__ = github_schema + __field_names__ = ("is_minimized", "minimized_reason", "viewer_can_minimize") + is_minimized = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isMinimized") + """Returns whether or not a comment has been minimized.""" + + minimized_reason = sgqlc.types.Field(String, graphql_name="minimizedReason") + """Returns why the comment was minimized.""" + + viewer_can_minimize = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanMinimize") + """Check if the current viewer can minimize this object.""" + + +class MinimizeCommentPayload(sgqlc.types.Type): + """Autogenerated return type of MinimizeComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "minimized_comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + minimized_comment = sgqlc.types.Field(Minimizable, graphql_name="minimizedComment") + """The comment that was minimized.""" + + +class MoveProjectCardPayload(sgqlc.types.Type): + """Autogenerated return type of MoveProjectCard""" + + __schema__ = github_schema + __field_names__ = ("card_edge", "client_mutation_id") + card_edge = sgqlc.types.Field("ProjectCardEdge", graphql_name="cardEdge") + """The new edge of the moved card.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class MoveProjectColumnPayload(sgqlc.types.Type): + """Autogenerated return type of MoveProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "column_edge") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + column_edge = sgqlc.types.Field("ProjectColumnEdge", graphql_name="columnEdge") + """The new edge of the moved column.""" + + +class Mutation(sgqlc.types.Type): + """The root query for implementing GraphQL mutations.""" + + __schema__ = github_schema + __field_names__ = ( + "abort_queued_migrations", + "accept_enterprise_administrator_invitation", + "accept_topic_suggestion", + "add_assignees_to_assignable", + "add_comment", + "add_discussion_comment", + "add_discussion_poll_vote", + "add_enterprise_support_entitlement", + "add_labels_to_labelable", + "add_project_card", + "add_project_column", + "add_project_draft_issue", + "add_project_next_item", + "add_pull_request_review", + "add_pull_request_review_comment", + "add_pull_request_review_thread", + "add_reaction", + "add_star", + "add_upvote", + "add_verifiable_domain", + "approve_deployments", + "approve_verifiable_domain", + "archive_repository", + "cancel_enterprise_admin_invitation", + "cancel_sponsorship", + "change_user_status", + "clear_labels_from_labelable", + "clone_project", + "clone_template_repository", + "close_issue", + "close_pull_request", + "convert_project_card_note_to_issue", + "convert_pull_request_to_draft", + "create_branch_protection_rule", + "create_check_run", + "create_check_suite", + "create_commit_on_branch", + "create_discussion", + "create_enterprise_organization", + "create_environment", + "create_ip_allow_list_entry", + "create_issue", + "create_migration_source", + "create_project", + "create_pull_request", + "create_ref", + "create_repository", + "create_sponsors_tier", + "create_sponsorship", + "create_team_discussion", + "create_team_discussion_comment", + "decline_topic_suggestion", + "delete_branch_protection_rule", + "delete_deployment", + "delete_discussion", + "delete_discussion_comment", + "delete_environment", + "delete_ip_allow_list_entry", + "delete_issue", + "delete_issue_comment", + "delete_project", + "delete_project_card", + "delete_project_column", + "delete_project_next_item", + "delete_pull_request_review", + "delete_pull_request_review_comment", + "delete_ref", + "delete_team_discussion", + "delete_team_discussion_comment", + "delete_verifiable_domain", + "disable_pull_request_auto_merge", + "dismiss_pull_request_review", + "dismiss_repository_vulnerability_alert", + "enable_pull_request_auto_merge", + "follow_organization", + "follow_user", + "grant_enterprise_organizations_migrator_role", + "grant_migrator_role", + "invite_enterprise_admin", + "link_repository_to_project", + "lock_lockable", + "mark_discussion_comment_as_answer", + "mark_file_as_viewed", + "mark_pull_request_ready_for_review", + "merge_branch", + "merge_pull_request", + "minimize_comment", + "move_project_card", + "move_project_column", + "pin_issue", + "regenerate_enterprise_identity_provider_recovery_codes", + "regenerate_verifiable_domain_token", + "reject_deployments", + "remove_assignees_from_assignable", + "remove_enterprise_admin", + "remove_enterprise_identity_provider", + "remove_enterprise_organization", + "remove_enterprise_support_entitlement", + "remove_labels_from_labelable", + "remove_outside_collaborator", + "remove_reaction", + "remove_star", + "remove_upvote", + "reopen_issue", + "reopen_pull_request", + "request_reviews", + "rerequest_check_suite", + "resolve_review_thread", + "revoke_enterprise_organizations_migrator_role", + "revoke_migrator_role", + "set_enterprise_identity_provider", + "set_organization_interaction_limit", + "set_repository_interaction_limit", + "set_user_interaction_limit", + "start_repository_migration", + "submit_pull_request_review", + "transfer_issue", + "unarchive_repository", + "unfollow_organization", + "unfollow_user", + "unlink_repository_from_project", + "unlock_lockable", + "unmark_discussion_comment_as_answer", + "unmark_file_as_viewed", + "unmark_issue_as_duplicate", + "unminimize_comment", + "unpin_issue", + "unresolve_review_thread", + "update_branch_protection_rule", + "update_check_run", + "update_check_suite_preferences", + "update_discussion", + "update_discussion_comment", + "update_enterprise_administrator_role", + "update_enterprise_allow_private_repository_forking_setting", + "update_enterprise_default_repository_permission_setting", + "update_enterprise_members_can_change_repository_visibility_setting", + "update_enterprise_members_can_create_repositories_setting", + "update_enterprise_members_can_delete_issues_setting", + "update_enterprise_members_can_delete_repositories_setting", + "update_enterprise_members_can_invite_collaborators_setting", + "update_enterprise_members_can_make_purchases_setting", + "update_enterprise_members_can_update_protected_branches_setting", + "update_enterprise_members_can_view_dependency_insights_setting", + "update_enterprise_organization_projects_setting", + "update_enterprise_owner_organization_role", + "update_enterprise_profile", + "update_enterprise_repository_projects_setting", + "update_enterprise_team_discussions_setting", + "update_enterprise_two_factor_authentication_required_setting", + "update_environment", + "update_ip_allow_list_enabled_setting", + "update_ip_allow_list_entry", + "update_ip_allow_list_for_installed_apps_enabled_setting", + "update_issue", + "update_issue_comment", + "update_notification_restriction_setting", + "update_organization_allow_private_repository_forking_setting", + "update_project", + "update_project_card", + "update_project_column", + "update_project_draft_issue", + "update_project_next", + "update_project_next_item_field", + "update_pull_request", + "update_pull_request_branch", + "update_pull_request_review", + "update_pull_request_review_comment", + "update_ref", + "update_repository", + "update_sponsorship_preferences", + "update_subscription", + "update_team_discussion", + "update_team_discussion_comment", + "update_teams_repository", + "update_topics", + "verify_verifiable_domain", + ) + abort_queued_migrations = sgqlc.types.Field( + AbortQueuedMigrationsPayload, + graphql_name="abortQueuedMigrations", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AbortQueuedMigrationsInput), graphql_name="input", default=None)),) + ), + ) + """Clear all of a customer's queued migrations + + Arguments: + + * `input` (`AbortQueuedMigrationsInput!`): Parameters for + AbortQueuedMigrations + """ + + accept_enterprise_administrator_invitation = sgqlc.types.Field( + AcceptEnterpriseAdministratorInvitationPayload, + graphql_name="acceptEnterpriseAdministratorInvitation", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg(sgqlc.types.non_null(AcceptEnterpriseAdministratorInvitationInput), graphql_name="input", default=None), + ), + ) + ), + ) + """Accepts a pending invitation for a user to become an administrator + of an enterprise. + + Arguments: + + * `input` (`AcceptEnterpriseAdministratorInvitationInput!`): + Parameters for AcceptEnterpriseAdministratorInvitation + """ + + accept_topic_suggestion = sgqlc.types.Field( + AcceptTopicSuggestionPayload, + graphql_name="acceptTopicSuggestion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AcceptTopicSuggestionInput), graphql_name="input", default=None)),) + ), + ) + """Applies a suggested topic to the repository. + + Arguments: + + * `input` (`AcceptTopicSuggestionInput!`): Parameters for + AcceptTopicSuggestion + """ + + add_assignees_to_assignable = sgqlc.types.Field( + AddAssigneesToAssignablePayload, + graphql_name="addAssigneesToAssignable", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddAssigneesToAssignableInput), graphql_name="input", default=None)),) + ), + ) + """Adds assignees to an assignable object. + + Arguments: + + * `input` (`AddAssigneesToAssignableInput!`): Parameters for + AddAssigneesToAssignable + """ + + add_comment = sgqlc.types.Field( + AddCommentPayload, + graphql_name="addComment", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(AddCommentInput), graphql_name="input", default=None)),)), + ) + """Adds a comment to an Issue or Pull Request. + + Arguments: + + * `input` (`AddCommentInput!`): Parameters for AddComment + """ + + add_discussion_comment = sgqlc.types.Field( + AddDiscussionCommentPayload, + graphql_name="addDiscussionComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddDiscussionCommentInput), graphql_name="input", default=None)),) + ), + ) + """Adds a comment to a Discussion, possibly as a reply to another + comment. + + Arguments: + + * `input` (`AddDiscussionCommentInput!`): Parameters for + AddDiscussionComment + """ + + add_discussion_poll_vote = sgqlc.types.Field( + AddDiscussionPollVotePayload, + graphql_name="addDiscussionPollVote", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddDiscussionPollVoteInput), graphql_name="input", default=None)),) + ), + ) + """Vote for an option in a discussion poll. + + Arguments: + + * `input` (`AddDiscussionPollVoteInput!`): Parameters for + AddDiscussionPollVote + """ + + add_enterprise_support_entitlement = sgqlc.types.Field( + AddEnterpriseSupportEntitlementPayload, + graphql_name="addEnterpriseSupportEntitlement", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddEnterpriseSupportEntitlementInput), graphql_name="input", default=None)),) + ), + ) + """Adds a support entitlement to an enterprise member. + + Arguments: + + * `input` (`AddEnterpriseSupportEntitlementInput!`): Parameters + for AddEnterpriseSupportEntitlement + """ + + add_labels_to_labelable = sgqlc.types.Field( + AddLabelsToLabelablePayload, + graphql_name="addLabelsToLabelable", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddLabelsToLabelableInput), graphql_name="input", default=None)),) + ), + ) + """Adds labels to a labelable object. + + Arguments: + + * `input` (`AddLabelsToLabelableInput!`): Parameters for + AddLabelsToLabelable + """ + + add_project_card = sgqlc.types.Field( + AddProjectCardPayload, + graphql_name="addProjectCard", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddProjectCardInput), graphql_name="input", default=None)),) + ), + ) + """Adds a card to a ProjectColumn. Either `contentId` or `note` must + be provided but **not** both. + + Arguments: + + * `input` (`AddProjectCardInput!`): Parameters for AddProjectCard + """ + + add_project_column = sgqlc.types.Field( + AddProjectColumnPayload, + graphql_name="addProjectColumn", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddProjectColumnInput), graphql_name="input", default=None)),) + ), + ) + """Adds a column to a Project. + + Arguments: + + * `input` (`AddProjectColumnInput!`): Parameters for + AddProjectColumn + """ + + add_project_draft_issue = sgqlc.types.Field( + AddProjectDraftIssuePayload, + graphql_name="addProjectDraftIssue", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddProjectDraftIssueInput), graphql_name="input", default=None)),) + ), + ) + """Creates a new draft issue and add it to a Project. + + Arguments: + + * `input` (`AddProjectDraftIssueInput!`): Parameters for + AddProjectDraftIssue + """ + + add_project_next_item = sgqlc.types.Field( + AddProjectNextItemPayload, + graphql_name="addProjectNextItem", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddProjectNextItemInput), graphql_name="input", default=None)),) + ), + ) + """Adds an existing item (Issue or PullRequest) to a Project. + + Arguments: + + * `input` (`AddProjectNextItemInput!`): Parameters for + AddProjectNextItem + """ + + add_pull_request_review = sgqlc.types.Field( + AddPullRequestReviewPayload, + graphql_name="addPullRequestReview", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddPullRequestReviewInput), graphql_name="input", default=None)),) + ), + ) + """Adds a review to a Pull Request. + + Arguments: + + * `input` (`AddPullRequestReviewInput!`): Parameters for + AddPullRequestReview + """ + + add_pull_request_review_comment = sgqlc.types.Field( + AddPullRequestReviewCommentPayload, + graphql_name="addPullRequestReviewComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddPullRequestReviewCommentInput), graphql_name="input", default=None)),) + ), + ) + """Adds a comment to a review. + + Arguments: + + * `input` (`AddPullRequestReviewCommentInput!`): Parameters for + AddPullRequestReviewComment + """ + + add_pull_request_review_thread = sgqlc.types.Field( + AddPullRequestReviewThreadPayload, + graphql_name="addPullRequestReviewThread", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddPullRequestReviewThreadInput), graphql_name="input", default=None)),) + ), + ) + """Adds a new thread to a pending Pull Request Review. + + Arguments: + + * `input` (`AddPullRequestReviewThreadInput!`): Parameters for + AddPullRequestReviewThread + """ + + add_reaction = sgqlc.types.Field( + AddReactionPayload, + graphql_name="addReaction", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(AddReactionInput), graphql_name="input", default=None)),)), + ) + """Adds a reaction to a subject. + + Arguments: + + * `input` (`AddReactionInput!`): Parameters for AddReaction + """ + + add_star = sgqlc.types.Field( + AddStarPayload, + graphql_name="addStar", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(AddStarInput), graphql_name="input", default=None)),)), + ) + """Adds a star to a Starrable. + + Arguments: + + * `input` (`AddStarInput!`): Parameters for AddStar + """ + + add_upvote = sgqlc.types.Field( + AddUpvotePayload, + graphql_name="addUpvote", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(AddUpvoteInput), graphql_name="input", default=None)),)), + ) + """Add an upvote to a discussion or discussion comment. + + Arguments: + + * `input` (`AddUpvoteInput!`): Parameters for AddUpvote + """ + + add_verifiable_domain = sgqlc.types.Field( + AddVerifiableDomainPayload, + graphql_name="addVerifiableDomain", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(AddVerifiableDomainInput), graphql_name="input", default=None)),) + ), + ) + """Adds a verifiable domain to an owning account. + + Arguments: + + * `input` (`AddVerifiableDomainInput!`): Parameters for + AddVerifiableDomain + """ + + approve_deployments = sgqlc.types.Field( + ApproveDeploymentsPayload, + graphql_name="approveDeployments", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ApproveDeploymentsInput), graphql_name="input", default=None)),) + ), + ) + """Approve all pending deployments under one or more environments + + Arguments: + + * `input` (`ApproveDeploymentsInput!`): Parameters for + ApproveDeployments + """ + + approve_verifiable_domain = sgqlc.types.Field( + ApproveVerifiableDomainPayload, + graphql_name="approveVerifiableDomain", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ApproveVerifiableDomainInput), graphql_name="input", default=None)),) + ), + ) + """Approve a verifiable domain for notification delivery. + + Arguments: + + * `input` (`ApproveVerifiableDomainInput!`): Parameters for + ApproveVerifiableDomain + """ + + archive_repository = sgqlc.types.Field( + ArchiveRepositoryPayload, + graphql_name="archiveRepository", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ArchiveRepositoryInput), graphql_name="input", default=None)),) + ), + ) + """Marks a repository as archived. + + Arguments: + + * `input` (`ArchiveRepositoryInput!`): Parameters for + ArchiveRepository + """ + + cancel_enterprise_admin_invitation = sgqlc.types.Field( + CancelEnterpriseAdminInvitationPayload, + graphql_name="cancelEnterpriseAdminInvitation", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CancelEnterpriseAdminInvitationInput), graphql_name="input", default=None)),) + ), + ) + """Cancels a pending invitation for an administrator to join an + enterprise. + + Arguments: + + * `input` (`CancelEnterpriseAdminInvitationInput!`): Parameters + for CancelEnterpriseAdminInvitation + """ + + cancel_sponsorship = sgqlc.types.Field( + CancelSponsorshipPayload, + graphql_name="cancelSponsorship", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CancelSponsorshipInput), graphql_name="input", default=None)),) + ), + ) + """Cancel an active sponsorship. + + Arguments: + + * `input` (`CancelSponsorshipInput!`): Parameters for + CancelSponsorship + """ + + change_user_status = sgqlc.types.Field( + ChangeUserStatusPayload, + graphql_name="changeUserStatus", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ChangeUserStatusInput), graphql_name="input", default=None)),) + ), + ) + """Update your status on GitHub. + + Arguments: + + * `input` (`ChangeUserStatusInput!`): Parameters for + ChangeUserStatus + """ + + clear_labels_from_labelable = sgqlc.types.Field( + ClearLabelsFromLabelablePayload, + graphql_name="clearLabelsFromLabelable", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ClearLabelsFromLabelableInput), graphql_name="input", default=None)),) + ), + ) + """Clears all labels from a labelable object. + + Arguments: + + * `input` (`ClearLabelsFromLabelableInput!`): Parameters for + ClearLabelsFromLabelable + """ + + clone_project = sgqlc.types.Field( + CloneProjectPayload, + graphql_name="cloneProject", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CloneProjectInput), graphql_name="input", default=None)),) + ), + ) + """Creates a new project by cloning configuration from an existing + project. + + Arguments: + + * `input` (`CloneProjectInput!`): Parameters for CloneProject + """ + + clone_template_repository = sgqlc.types.Field( + CloneTemplateRepositoryPayload, + graphql_name="cloneTemplateRepository", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CloneTemplateRepositoryInput), graphql_name="input", default=None)),) + ), + ) + """Create a new repository with the same files and directory + structure as a template repository. + + Arguments: + + * `input` (`CloneTemplateRepositoryInput!`): Parameters for + CloneTemplateRepository + """ + + close_issue = sgqlc.types.Field( + CloseIssuePayload, + graphql_name="closeIssue", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(CloseIssueInput), graphql_name="input", default=None)),)), + ) + """Close an issue. + + Arguments: + + * `input` (`CloseIssueInput!`): Parameters for CloseIssue + """ + + close_pull_request = sgqlc.types.Field( + ClosePullRequestPayload, + graphql_name="closePullRequest", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ClosePullRequestInput), graphql_name="input", default=None)),) + ), + ) + """Close a pull request. + + Arguments: + + * `input` (`ClosePullRequestInput!`): Parameters for + ClosePullRequest + """ + + convert_project_card_note_to_issue = sgqlc.types.Field( + ConvertProjectCardNoteToIssuePayload, + graphql_name="convertProjectCardNoteToIssue", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ConvertProjectCardNoteToIssueInput), graphql_name="input", default=None)),) + ), + ) + """Convert a project note card to one associated with a newly created + issue. + + Arguments: + + * `input` (`ConvertProjectCardNoteToIssueInput!`): Parameters for + ConvertProjectCardNoteToIssue + """ + + convert_pull_request_to_draft = sgqlc.types.Field( + ConvertPullRequestToDraftPayload, + graphql_name="convertPullRequestToDraft", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ConvertPullRequestToDraftInput), graphql_name="input", default=None)),) + ), + ) + """Converts a pull request to draft + + Arguments: + + * `input` (`ConvertPullRequestToDraftInput!`): Parameters for + ConvertPullRequestToDraft + """ + + create_branch_protection_rule = sgqlc.types.Field( + CreateBranchProtectionRulePayload, + graphql_name="createBranchProtectionRule", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateBranchProtectionRuleInput), graphql_name="input", default=None)),) + ), + ) + """Create a new branch protection rule + + Arguments: + + * `input` (`CreateBranchProtectionRuleInput!`): Parameters for + CreateBranchProtectionRule + """ + + create_check_run = sgqlc.types.Field( + CreateCheckRunPayload, + graphql_name="createCheckRun", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateCheckRunInput), graphql_name="input", default=None)),) + ), + ) + """Create a check run. + + Arguments: + + * `input` (`CreateCheckRunInput!`): Parameters for CreateCheckRun + """ + + create_check_suite = sgqlc.types.Field( + CreateCheckSuitePayload, + graphql_name="createCheckSuite", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateCheckSuiteInput), graphql_name="input", default=None)),) + ), + ) + """Create a check suite + + Arguments: + + * `input` (`CreateCheckSuiteInput!`): Parameters for + CreateCheckSuite + """ + + create_commit_on_branch = sgqlc.types.Field( + CreateCommitOnBranchPayload, + graphql_name="createCommitOnBranch", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateCommitOnBranchInput), graphql_name="input", default=None)),) + ), + ) + """Appends a commit to the given branch as the authenticated user. + This mutation creates a commit whose parent is the HEAD of the + provided branch and also updates that branch to point to the new + commit. It can be thought of as similar to `git commit`. ### + Locating a Branch Commits are appended to a `branch` of type + `Ref`. This must refer to a git branch (i.e. the fully qualified + path must begin with `refs/heads/`, although including this prefix + is optional. Callers may specify the `branch` to commit to either + by its global node ID or by passing both of + `repositoryNameWithOwner` and `refName`. For more details see the + documentation for `CommittableBranch`. ### Describing Changes + `fileChanges` are specified as a `FilesChanges` object describing + `FileAdditions` and `FileDeletions`. Please see the documentation + for `FileChanges` for more information on how to use this argument + to describe any set of file changes. ### Authorship Similar to + the web commit interface, this mutation does not support + specifying the author or committer of the commit and will not add + support for this in the future. A commit created by a successful + execution of this mutation will be authored by the owner of the + credential which authenticates the API request. The committer + will be identical to that of commits authored using the web + interface. If you need full control over author and committer + information, please use the Git Database REST API instead. ### + Commit Signing Commits made using this mutation are automatically + signed by GitHub if supported and will be marked as verified in + the user interface. + + Arguments: + + * `input` (`CreateCommitOnBranchInput!`): Parameters for + CreateCommitOnBranch + """ + + create_discussion = sgqlc.types.Field( + CreateDiscussionPayload, + graphql_name="createDiscussion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateDiscussionInput), graphql_name="input", default=None)),) + ), + ) + """Create a discussion. + + Arguments: + + * `input` (`CreateDiscussionInput!`): Parameters for + CreateDiscussion + """ + + create_enterprise_organization = sgqlc.types.Field( + CreateEnterpriseOrganizationPayload, + graphql_name="createEnterpriseOrganization", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateEnterpriseOrganizationInput), graphql_name="input", default=None)),) + ), + ) + """Creates an organization as part of an enterprise account. + + Arguments: + + * `input` (`CreateEnterpriseOrganizationInput!`): Parameters for + CreateEnterpriseOrganization + """ + + create_environment = sgqlc.types.Field( + CreateEnvironmentPayload, + graphql_name="createEnvironment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateEnvironmentInput), graphql_name="input", default=None)),) + ), + ) + """Creates an environment or simply returns it if already exists. + + Arguments: + + * `input` (`CreateEnvironmentInput!`): Parameters for + CreateEnvironment + """ + + create_ip_allow_list_entry = sgqlc.types.Field( + CreateIpAllowListEntryPayload, + graphql_name="createIpAllowListEntry", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateIpAllowListEntryInput), graphql_name="input", default=None)),) + ), + ) + """Creates a new IP allow list entry. + + Arguments: + + * `input` (`CreateIpAllowListEntryInput!`): Parameters for + CreateIpAllowListEntry + """ + + create_issue = sgqlc.types.Field( + CreateIssuePayload, + graphql_name="createIssue", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateIssueInput), graphql_name="input", default=None)),)), + ) + """Creates a new issue. + + Arguments: + + * `input` (`CreateIssueInput!`): Parameters for CreateIssue + """ + + create_migration_source = sgqlc.types.Field( + CreateMigrationSourcePayload, + graphql_name="createMigrationSource", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateMigrationSourceInput), graphql_name="input", default=None)),) + ), + ) + """Creates an Octoshift migration source. + + Arguments: + + * `input` (`CreateMigrationSourceInput!`): Parameters for + CreateMigrationSource + """ + + create_project = sgqlc.types.Field( + CreateProjectPayload, + graphql_name="createProject", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateProjectInput), graphql_name="input", default=None)),) + ), + ) + """Creates a new project. + + Arguments: + + * `input` (`CreateProjectInput!`): Parameters for CreateProject + """ + + create_pull_request = sgqlc.types.Field( + CreatePullRequestPayload, + graphql_name="createPullRequest", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreatePullRequestInput), graphql_name="input", default=None)),) + ), + ) + """Create a new pull request + + Arguments: + + * `input` (`CreatePullRequestInput!`): Parameters for + CreatePullRequest + """ + + create_ref = sgqlc.types.Field( + CreateRefPayload, + graphql_name="createRef", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateRefInput), graphql_name="input", default=None)),)), + ) + """Create a new Git Ref. + + Arguments: + + * `input` (`CreateRefInput!`): Parameters for CreateRef + """ + + create_repository = sgqlc.types.Field( + CreateRepositoryPayload, + graphql_name="createRepository", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateRepositoryInput), graphql_name="input", default=None)),) + ), + ) + """Create a new repository. + + Arguments: + + * `input` (`CreateRepositoryInput!`): Parameters for + CreateRepository + """ + + create_sponsors_tier = sgqlc.types.Field( + CreateSponsorsTierPayload, + graphql_name="createSponsorsTier", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateSponsorsTierInput), graphql_name="input", default=None)),) + ), + ) + """Create a new payment tier for your GitHub Sponsors profile. + + Arguments: + + * `input` (`CreateSponsorsTierInput!`): Parameters for + CreateSponsorsTier + """ + + create_sponsorship = sgqlc.types.Field( + CreateSponsorshipPayload, + graphql_name="createSponsorship", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateSponsorshipInput), graphql_name="input", default=None)),) + ), + ) + """Start a new sponsorship of a maintainer in GitHub Sponsors, or + reactivate a past sponsorship. + + Arguments: + + * `input` (`CreateSponsorshipInput!`): Parameters for + CreateSponsorship + """ + + create_team_discussion = sgqlc.types.Field( + CreateTeamDiscussionPayload, + graphql_name="createTeamDiscussion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateTeamDiscussionInput), graphql_name="input", default=None)),) + ), + ) + """Creates a new team discussion. + + Arguments: + + * `input` (`CreateTeamDiscussionInput!`): Parameters for + CreateTeamDiscussion + """ + + create_team_discussion_comment = sgqlc.types.Field( + CreateTeamDiscussionCommentPayload, + graphql_name="createTeamDiscussionComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(CreateTeamDiscussionCommentInput), graphql_name="input", default=None)),) + ), + ) + """Creates a new team discussion comment. + + Arguments: + + * `input` (`CreateTeamDiscussionCommentInput!`): Parameters for + CreateTeamDiscussionComment + """ + + decline_topic_suggestion = sgqlc.types.Field( + DeclineTopicSuggestionPayload, + graphql_name="declineTopicSuggestion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeclineTopicSuggestionInput), graphql_name="input", default=None)),) + ), + ) + """Rejects a suggested topic for the repository. + + Arguments: + + * `input` (`DeclineTopicSuggestionInput!`): Parameters for + DeclineTopicSuggestion + """ + + delete_branch_protection_rule = sgqlc.types.Field( + DeleteBranchProtectionRulePayload, + graphql_name="deleteBranchProtectionRule", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteBranchProtectionRuleInput), graphql_name="input", default=None)),) + ), + ) + """Delete a branch protection rule + + Arguments: + + * `input` (`DeleteBranchProtectionRuleInput!`): Parameters for + DeleteBranchProtectionRule + """ + + delete_deployment = sgqlc.types.Field( + DeleteDeploymentPayload, + graphql_name="deleteDeployment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteDeploymentInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a deployment. + + Arguments: + + * `input` (`DeleteDeploymentInput!`): Parameters for + DeleteDeployment + """ + + delete_discussion = sgqlc.types.Field( + DeleteDiscussionPayload, + graphql_name="deleteDiscussion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteDiscussionInput), graphql_name="input", default=None)),) + ), + ) + """Delete a discussion and all of its replies. + + Arguments: + + * `input` (`DeleteDiscussionInput!`): Parameters for + DeleteDiscussion + """ + + delete_discussion_comment = sgqlc.types.Field( + DeleteDiscussionCommentPayload, + graphql_name="deleteDiscussionComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteDiscussionCommentInput), graphql_name="input", default=None)),) + ), + ) + """Delete a discussion comment. If it has replies, wipe it instead. + + Arguments: + + * `input` (`DeleteDiscussionCommentInput!`): Parameters for + DeleteDiscussionComment + """ + + delete_environment = sgqlc.types.Field( + DeleteEnvironmentPayload, + graphql_name="deleteEnvironment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteEnvironmentInput), graphql_name="input", default=None)),) + ), + ) + """Deletes an environment + + Arguments: + + * `input` (`DeleteEnvironmentInput!`): Parameters for + DeleteEnvironment + """ + + delete_ip_allow_list_entry = sgqlc.types.Field( + DeleteIpAllowListEntryPayload, + graphql_name="deleteIpAllowListEntry", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteIpAllowListEntryInput), graphql_name="input", default=None)),) + ), + ) + """Deletes an IP allow list entry. + + Arguments: + + * `input` (`DeleteIpAllowListEntryInput!`): Parameters for + DeleteIpAllowListEntry + """ + + delete_issue = sgqlc.types.Field( + DeleteIssuePayload, + graphql_name="deleteIssue", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteIssueInput), graphql_name="input", default=None)),)), + ) + """Deletes an Issue object. + + Arguments: + + * `input` (`DeleteIssueInput!`): Parameters for DeleteIssue + """ + + delete_issue_comment = sgqlc.types.Field( + DeleteIssueCommentPayload, + graphql_name="deleteIssueComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteIssueCommentInput), graphql_name="input", default=None)),) + ), + ) + """Deletes an IssueComment object. + + Arguments: + + * `input` (`DeleteIssueCommentInput!`): Parameters for + DeleteIssueComment + """ + + delete_project = sgqlc.types.Field( + DeleteProjectPayload, + graphql_name="deleteProject", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteProjectInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a project. + + Arguments: + + * `input` (`DeleteProjectInput!`): Parameters for DeleteProject + """ + + delete_project_card = sgqlc.types.Field( + DeleteProjectCardPayload, + graphql_name="deleteProjectCard", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteProjectCardInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a project card. + + Arguments: + + * `input` (`DeleteProjectCardInput!`): Parameters for + DeleteProjectCard + """ + + delete_project_column = sgqlc.types.Field( + DeleteProjectColumnPayload, + graphql_name="deleteProjectColumn", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteProjectColumnInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a project column. + + Arguments: + + * `input` (`DeleteProjectColumnInput!`): Parameters for + DeleteProjectColumn + """ + + delete_project_next_item = sgqlc.types.Field( + DeleteProjectNextItemPayload, + graphql_name="deleteProjectNextItem", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteProjectNextItemInput), graphql_name="input", default=None)),) + ), + ) + """Deletes an item from a Project. + + Arguments: + + * `input` (`DeleteProjectNextItemInput!`): Parameters for + DeleteProjectNextItem + """ + + delete_pull_request_review = sgqlc.types.Field( + DeletePullRequestReviewPayload, + graphql_name="deletePullRequestReview", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeletePullRequestReviewInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a pull request review. + + Arguments: + + * `input` (`DeletePullRequestReviewInput!`): Parameters for + DeletePullRequestReview + """ + + delete_pull_request_review_comment = sgqlc.types.Field( + DeletePullRequestReviewCommentPayload, + graphql_name="deletePullRequestReviewComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeletePullRequestReviewCommentInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a pull request review comment. + + Arguments: + + * `input` (`DeletePullRequestReviewCommentInput!`): Parameters for + DeletePullRequestReviewComment + """ + + delete_ref = sgqlc.types.Field( + DeleteRefPayload, + graphql_name="deleteRef", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteRefInput), graphql_name="input", default=None)),)), + ) + """Delete a Git Ref. + + Arguments: + + * `input` (`DeleteRefInput!`): Parameters for DeleteRef + """ + + delete_team_discussion = sgqlc.types.Field( + DeleteTeamDiscussionPayload, + graphql_name="deleteTeamDiscussion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteTeamDiscussionInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a team discussion. + + Arguments: + + * `input` (`DeleteTeamDiscussionInput!`): Parameters for + DeleteTeamDiscussion + """ + + delete_team_discussion_comment = sgqlc.types.Field( + DeleteTeamDiscussionCommentPayload, + graphql_name="deleteTeamDiscussionComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteTeamDiscussionCommentInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a team discussion comment. + + Arguments: + + * `input` (`DeleteTeamDiscussionCommentInput!`): Parameters for + DeleteTeamDiscussionComment + """ + + delete_verifiable_domain = sgqlc.types.Field( + DeleteVerifiableDomainPayload, + graphql_name="deleteVerifiableDomain", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DeleteVerifiableDomainInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a verifiable domain. + + Arguments: + + * `input` (`DeleteVerifiableDomainInput!`): Parameters for + DeleteVerifiableDomain + """ + + disable_pull_request_auto_merge = sgqlc.types.Field( + DisablePullRequestAutoMergePayload, + graphql_name="disablePullRequestAutoMerge", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DisablePullRequestAutoMergeInput), graphql_name="input", default=None)),) + ), + ) + """Disable auto merge on the given pull request + + Arguments: + + * `input` (`DisablePullRequestAutoMergeInput!`): Parameters for + DisablePullRequestAutoMerge + """ + + dismiss_pull_request_review = sgqlc.types.Field( + DismissPullRequestReviewPayload, + graphql_name="dismissPullRequestReview", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(DismissPullRequestReviewInput), graphql_name="input", default=None)),) + ), + ) + """Dismisses an approved or rejected pull request review. + + Arguments: + + * `input` (`DismissPullRequestReviewInput!`): Parameters for + DismissPullRequestReview + """ + + dismiss_repository_vulnerability_alert = sgqlc.types.Field( + DismissRepositoryVulnerabilityAlertPayload, + graphql_name="dismissRepositoryVulnerabilityAlert", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg(sgqlc.types.non_null(DismissRepositoryVulnerabilityAlertInput), graphql_name="input", default=None), + ), + ) + ), + ) + """Dismisses the Dependabot alert. + + Arguments: + + * `input` (`DismissRepositoryVulnerabilityAlertInput!`): + Parameters for DismissRepositoryVulnerabilityAlert + """ + + enable_pull_request_auto_merge = sgqlc.types.Field( + EnablePullRequestAutoMergePayload, + graphql_name="enablePullRequestAutoMerge", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(EnablePullRequestAutoMergeInput), graphql_name="input", default=None)),) + ), + ) + """Enable the default auto-merge on a pull request. + + Arguments: + + * `input` (`EnablePullRequestAutoMergeInput!`): Parameters for + EnablePullRequestAutoMerge + """ + + follow_organization = sgqlc.types.Field( + FollowOrganizationPayload, + graphql_name="followOrganization", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(FollowOrganizationInput), graphql_name="input", default=None)),) + ), + ) + """Follow an organization. + + Arguments: + + * `input` (`FollowOrganizationInput!`): Parameters for + FollowOrganization + """ + + follow_user = sgqlc.types.Field( + FollowUserPayload, + graphql_name="followUser", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(FollowUserInput), graphql_name="input", default=None)),)), + ) + """Follow a user. + + Arguments: + + * `input` (`FollowUserInput!`): Parameters for FollowUser + """ + + grant_enterprise_organizations_migrator_role = sgqlc.types.Field( + GrantEnterpriseOrganizationsMigratorRolePayload, + graphql_name="grantEnterpriseOrganizationsMigratorRole", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(GrantEnterpriseOrganizationsMigratorRoleInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Grant the migrator role to a user for all organizations under an + enterprise account. + + Arguments: + + * `input` (`GrantEnterpriseOrganizationsMigratorRoleInput!`): + Parameters for GrantEnterpriseOrganizationsMigratorRole + """ + + grant_migrator_role = sgqlc.types.Field( + GrantMigratorRolePayload, + graphql_name="grantMigratorRole", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(GrantMigratorRoleInput), graphql_name="input", default=None)),) + ), + ) + """Grant the migrator role to a user or a team. + + Arguments: + + * `input` (`GrantMigratorRoleInput!`): Parameters for + GrantMigratorRole + """ + + invite_enterprise_admin = sgqlc.types.Field( + InviteEnterpriseAdminPayload, + graphql_name="inviteEnterpriseAdmin", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(InviteEnterpriseAdminInput), graphql_name="input", default=None)),) + ), + ) + """Invite someone to become an administrator of the enterprise. + + Arguments: + + * `input` (`InviteEnterpriseAdminInput!`): Parameters for + InviteEnterpriseAdmin + """ + + link_repository_to_project = sgqlc.types.Field( + LinkRepositoryToProjectPayload, + graphql_name="linkRepositoryToProject", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(LinkRepositoryToProjectInput), graphql_name="input", default=None)),) + ), + ) + """Creates a repository link for a project. + + Arguments: + + * `input` (`LinkRepositoryToProjectInput!`): Parameters for + LinkRepositoryToProject + """ + + lock_lockable = sgqlc.types.Field( + LockLockablePayload, + graphql_name="lockLockable", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(LockLockableInput), graphql_name="input", default=None)),) + ), + ) + """Lock a lockable object + + Arguments: + + * `input` (`LockLockableInput!`): Parameters for LockLockable + """ + + mark_discussion_comment_as_answer = sgqlc.types.Field( + MarkDiscussionCommentAsAnswerPayload, + graphql_name="markDiscussionCommentAsAnswer", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(MarkDiscussionCommentAsAnswerInput), graphql_name="input", default=None)),) + ), + ) + """Mark a discussion comment as the chosen answer for discussions in + an answerable category. + + Arguments: + + * `input` (`MarkDiscussionCommentAsAnswerInput!`): Parameters for + MarkDiscussionCommentAsAnswer + """ + + mark_file_as_viewed = sgqlc.types.Field( + MarkFileAsViewedPayload, + graphql_name="markFileAsViewed", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(MarkFileAsViewedInput), graphql_name="input", default=None)),) + ), + ) + """Mark a pull request file as viewed + + Arguments: + + * `input` (`MarkFileAsViewedInput!`): Parameters for + MarkFileAsViewed + """ + + mark_pull_request_ready_for_review = sgqlc.types.Field( + MarkPullRequestReadyForReviewPayload, + graphql_name="markPullRequestReadyForReview", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(MarkPullRequestReadyForReviewInput), graphql_name="input", default=None)),) + ), + ) + """Marks a pull request ready for review. + + Arguments: + + * `input` (`MarkPullRequestReadyForReviewInput!`): Parameters for + MarkPullRequestReadyForReview + """ + + merge_branch = sgqlc.types.Field( + MergeBranchPayload, + graphql_name="mergeBranch", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(MergeBranchInput), graphql_name="input", default=None)),)), + ) + """Merge a head into a branch. + + Arguments: + + * `input` (`MergeBranchInput!`): Parameters for MergeBranch + """ + + merge_pull_request = sgqlc.types.Field( + MergePullRequestPayload, + graphql_name="mergePullRequest", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(MergePullRequestInput), graphql_name="input", default=None)),) + ), + ) + """Merge a pull request. + + Arguments: + + * `input` (`MergePullRequestInput!`): Parameters for + MergePullRequest + """ + + minimize_comment = sgqlc.types.Field( + MinimizeCommentPayload, + graphql_name="minimizeComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(MinimizeCommentInput), graphql_name="input", default=None)),) + ), + ) + """Minimizes a comment on an Issue, Commit, Pull Request, or Gist + + Arguments: + + * `input` (`MinimizeCommentInput!`): Parameters for + MinimizeComment + """ + + move_project_card = sgqlc.types.Field( + MoveProjectCardPayload, + graphql_name="moveProjectCard", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(MoveProjectCardInput), graphql_name="input", default=None)),) + ), + ) + """Moves a project card to another place. + + Arguments: + + * `input` (`MoveProjectCardInput!`): Parameters for + MoveProjectCard + """ + + move_project_column = sgqlc.types.Field( + MoveProjectColumnPayload, + graphql_name="moveProjectColumn", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(MoveProjectColumnInput), graphql_name="input", default=None)),) + ), + ) + """Moves a project column to another place. + + Arguments: + + * `input` (`MoveProjectColumnInput!`): Parameters for + MoveProjectColumn + """ + + pin_issue = sgqlc.types.Field( + "PinIssuePayload", + graphql_name="pinIssue", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(PinIssueInput), graphql_name="input", default=None)),)), + ) + """Pin an issue to a repository + + Arguments: + + * `input` (`PinIssueInput!`): Parameters for PinIssue + """ + + regenerate_enterprise_identity_provider_recovery_codes = sgqlc.types.Field( + "RegenerateEnterpriseIdentityProviderRecoveryCodesPayload", + graphql_name="regenerateEnterpriseIdentityProviderRecoveryCodes", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(RegenerateEnterpriseIdentityProviderRecoveryCodesInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Regenerates the identity provider recovery codes for an enterprise + + Arguments: + + * `input` + (`RegenerateEnterpriseIdentityProviderRecoveryCodesInput!`): + Parameters for RegenerateEnterpriseIdentityProviderRecoveryCodes + """ + + regenerate_verifiable_domain_token = sgqlc.types.Field( + "RegenerateVerifiableDomainTokenPayload", + graphql_name="regenerateVerifiableDomainToken", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RegenerateVerifiableDomainTokenInput), graphql_name="input", default=None)),) + ), + ) + """Regenerates a verifiable domain's verification token. + + Arguments: + + * `input` (`RegenerateVerifiableDomainTokenInput!`): Parameters + for RegenerateVerifiableDomainToken + """ + + reject_deployments = sgqlc.types.Field( + "RejectDeploymentsPayload", + graphql_name="rejectDeployments", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RejectDeploymentsInput), graphql_name="input", default=None)),) + ), + ) + """Reject all pending deployments under one or more environments + + Arguments: + + * `input` (`RejectDeploymentsInput!`): Parameters for + RejectDeployments + """ + + remove_assignees_from_assignable = sgqlc.types.Field( + "RemoveAssigneesFromAssignablePayload", + graphql_name="removeAssigneesFromAssignable", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveAssigneesFromAssignableInput), graphql_name="input", default=None)),) + ), + ) + """Removes assignees from an assignable object. + + Arguments: + + * `input` (`RemoveAssigneesFromAssignableInput!`): Parameters for + RemoveAssigneesFromAssignable + """ + + remove_enterprise_admin = sgqlc.types.Field( + "RemoveEnterpriseAdminPayload", + graphql_name="removeEnterpriseAdmin", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveEnterpriseAdminInput), graphql_name="input", default=None)),) + ), + ) + """Removes an administrator from the enterprise. + + Arguments: + + * `input` (`RemoveEnterpriseAdminInput!`): Parameters for + RemoveEnterpriseAdmin + """ + + remove_enterprise_identity_provider = sgqlc.types.Field( + "RemoveEnterpriseIdentityProviderPayload", + graphql_name="removeEnterpriseIdentityProvider", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveEnterpriseIdentityProviderInput), graphql_name="input", default=None)),) + ), + ) + """Removes the identity provider from an enterprise + + Arguments: + + * `input` (`RemoveEnterpriseIdentityProviderInput!`): Parameters + for RemoveEnterpriseIdentityProvider + """ + + remove_enterprise_organization = sgqlc.types.Field( + "RemoveEnterpriseOrganizationPayload", + graphql_name="removeEnterpriseOrganization", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveEnterpriseOrganizationInput), graphql_name="input", default=None)),) + ), + ) + """Removes an organization from the enterprise + + Arguments: + + * `input` (`RemoveEnterpriseOrganizationInput!`): Parameters for + RemoveEnterpriseOrganization + """ + + remove_enterprise_support_entitlement = sgqlc.types.Field( + "RemoveEnterpriseSupportEntitlementPayload", + graphql_name="removeEnterpriseSupportEntitlement", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveEnterpriseSupportEntitlementInput), graphql_name="input", default=None)),) + ), + ) + """Removes a support entitlement from an enterprise member. + + Arguments: + + * `input` (`RemoveEnterpriseSupportEntitlementInput!`): Parameters + for RemoveEnterpriseSupportEntitlement + """ + + remove_labels_from_labelable = sgqlc.types.Field( + "RemoveLabelsFromLabelablePayload", + graphql_name="removeLabelsFromLabelable", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveLabelsFromLabelableInput), graphql_name="input", default=None)),) + ), + ) + """Removes labels from a Labelable object. + + Arguments: + + * `input` (`RemoveLabelsFromLabelableInput!`): Parameters for + RemoveLabelsFromLabelable + """ + + remove_outside_collaborator = sgqlc.types.Field( + "RemoveOutsideCollaboratorPayload", + graphql_name="removeOutsideCollaborator", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveOutsideCollaboratorInput), graphql_name="input", default=None)),) + ), + ) + """Removes outside collaborator from all repositories in an + organization. + + Arguments: + + * `input` (`RemoveOutsideCollaboratorInput!`): Parameters for + RemoveOutsideCollaborator + """ + + remove_reaction = sgqlc.types.Field( + "RemoveReactionPayload", + graphql_name="removeReaction", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveReactionInput), graphql_name="input", default=None)),) + ), + ) + """Removes a reaction from a subject. + + Arguments: + + * `input` (`RemoveReactionInput!`): Parameters for RemoveReaction + """ + + remove_star = sgqlc.types.Field( + "RemoveStarPayload", + graphql_name="removeStar", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveStarInput), graphql_name="input", default=None)),)), + ) + """Removes a star from a Starrable. + + Arguments: + + * `input` (`RemoveStarInput!`): Parameters for RemoveStar + """ + + remove_upvote = sgqlc.types.Field( + "RemoveUpvotePayload", + graphql_name="removeUpvote", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RemoveUpvoteInput), graphql_name="input", default=None)),) + ), + ) + """Remove an upvote to a discussion or discussion comment. + + Arguments: + + * `input` (`RemoveUpvoteInput!`): Parameters for RemoveUpvote + """ + + reopen_issue = sgqlc.types.Field( + "ReopenIssuePayload", + graphql_name="reopenIssue", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(ReopenIssueInput), graphql_name="input", default=None)),)), + ) + """Reopen a issue. + + Arguments: + + * `input` (`ReopenIssueInput!`): Parameters for ReopenIssue + """ + + reopen_pull_request = sgqlc.types.Field( + "ReopenPullRequestPayload", + graphql_name="reopenPullRequest", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ReopenPullRequestInput), graphql_name="input", default=None)),) + ), + ) + """Reopen a pull request. + + Arguments: + + * `input` (`ReopenPullRequestInput!`): Parameters for + ReopenPullRequest + """ + + request_reviews = sgqlc.types.Field( + "RequestReviewsPayload", + graphql_name="requestReviews", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RequestReviewsInput), graphql_name="input", default=None)),) + ), + ) + """Set review requests on a pull request. + + Arguments: + + * `input` (`RequestReviewsInput!`): Parameters for RequestReviews + """ + + rerequest_check_suite = sgqlc.types.Field( + "RerequestCheckSuitePayload", + graphql_name="rerequestCheckSuite", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RerequestCheckSuiteInput), graphql_name="input", default=None)),) + ), + ) + """Rerequests an existing check suite. + + Arguments: + + * `input` (`RerequestCheckSuiteInput!`): Parameters for + RerequestCheckSuite + """ + + resolve_review_thread = sgqlc.types.Field( + "ResolveReviewThreadPayload", + graphql_name="resolveReviewThread", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(ResolveReviewThreadInput), graphql_name="input", default=None)),) + ), + ) + """Marks a review thread as resolved. + + Arguments: + + * `input` (`ResolveReviewThreadInput!`): Parameters for + ResolveReviewThread + """ + + revoke_enterprise_organizations_migrator_role = sgqlc.types.Field( + "RevokeEnterpriseOrganizationsMigratorRolePayload", + graphql_name="revokeEnterpriseOrganizationsMigratorRole", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(RevokeEnterpriseOrganizationsMigratorRoleInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Revoke the migrator role to a user for all organizations under an + enterprise account. + + Arguments: + + * `input` (`RevokeEnterpriseOrganizationsMigratorRoleInput!`): + Parameters for RevokeEnterpriseOrganizationsMigratorRole + """ + + revoke_migrator_role = sgqlc.types.Field( + "RevokeMigratorRolePayload", + graphql_name="revokeMigratorRole", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(RevokeMigratorRoleInput), graphql_name="input", default=None)),) + ), + ) + """Revoke the migrator role from a user or a team. + + Arguments: + + * `input` (`RevokeMigratorRoleInput!`): Parameters for + RevokeMigratorRole + """ + + set_enterprise_identity_provider = sgqlc.types.Field( + "SetEnterpriseIdentityProviderPayload", + graphql_name="setEnterpriseIdentityProvider", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(SetEnterpriseIdentityProviderInput), graphql_name="input", default=None)),) + ), + ) + """Creates or updates the identity provider for an enterprise. + + Arguments: + + * `input` (`SetEnterpriseIdentityProviderInput!`): Parameters for + SetEnterpriseIdentityProvider + """ + + set_organization_interaction_limit = sgqlc.types.Field( + "SetOrganizationInteractionLimitPayload", + graphql_name="setOrganizationInteractionLimit", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(SetOrganizationInteractionLimitInput), graphql_name="input", default=None)),) + ), + ) + """Set an organization level interaction limit for an organization's + public repositories. + + Arguments: + + * `input` (`SetOrganizationInteractionLimitInput!`): Parameters + for SetOrganizationInteractionLimit + """ + + set_repository_interaction_limit = sgqlc.types.Field( + "SetRepositoryInteractionLimitPayload", + graphql_name="setRepositoryInteractionLimit", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(SetRepositoryInteractionLimitInput), graphql_name="input", default=None)),) + ), + ) + """Sets an interaction limit setting for a repository. + + Arguments: + + * `input` (`SetRepositoryInteractionLimitInput!`): Parameters for + SetRepositoryInteractionLimit + """ + + set_user_interaction_limit = sgqlc.types.Field( + "SetUserInteractionLimitPayload", + graphql_name="setUserInteractionLimit", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(SetUserInteractionLimitInput), graphql_name="input", default=None)),) + ), + ) + """Set a user level interaction limit for an user's public + repositories. + + Arguments: + + * `input` (`SetUserInteractionLimitInput!`): Parameters for + SetUserInteractionLimit + """ + + start_repository_migration = sgqlc.types.Field( + "StartRepositoryMigrationPayload", + graphql_name="startRepositoryMigration", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(StartRepositoryMigrationInput), graphql_name="input", default=None)),) + ), + ) + """Start a repository migration. + + Arguments: + + * `input` (`StartRepositoryMigrationInput!`): Parameters for + StartRepositoryMigration + """ + + submit_pull_request_review = sgqlc.types.Field( + "SubmitPullRequestReviewPayload", + graphql_name="submitPullRequestReview", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(SubmitPullRequestReviewInput), graphql_name="input", default=None)),) + ), + ) + """Submits a pending pull request review. + + Arguments: + + * `input` (`SubmitPullRequestReviewInput!`): Parameters for + SubmitPullRequestReview + """ + + transfer_issue = sgqlc.types.Field( + "TransferIssuePayload", + graphql_name="transferIssue", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(TransferIssueInput), graphql_name="input", default=None)),) + ), + ) + """Transfer an issue to a different repository + + Arguments: + + * `input` (`TransferIssueInput!`): Parameters for TransferIssue + """ + + unarchive_repository = sgqlc.types.Field( + "UnarchiveRepositoryPayload", + graphql_name="unarchiveRepository", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnarchiveRepositoryInput), graphql_name="input", default=None)),) + ), + ) + """Unarchives a repository. + + Arguments: + + * `input` (`UnarchiveRepositoryInput!`): Parameters for + UnarchiveRepository + """ + + unfollow_organization = sgqlc.types.Field( + "UnfollowOrganizationPayload", + graphql_name="unfollowOrganization", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnfollowOrganizationInput), graphql_name="input", default=None)),) + ), + ) + """Unfollow an organization. + + Arguments: + + * `input` (`UnfollowOrganizationInput!`): Parameters for + UnfollowOrganization + """ + + unfollow_user = sgqlc.types.Field( + "UnfollowUserPayload", + graphql_name="unfollowUser", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnfollowUserInput), graphql_name="input", default=None)),) + ), + ) + """Unfollow a user. + + Arguments: + + * `input` (`UnfollowUserInput!`): Parameters for UnfollowUser + """ + + unlink_repository_from_project = sgqlc.types.Field( + "UnlinkRepositoryFromProjectPayload", + graphql_name="unlinkRepositoryFromProject", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnlinkRepositoryFromProjectInput), graphql_name="input", default=None)),) + ), + ) + """Deletes a repository link from a project. + + Arguments: + + * `input` (`UnlinkRepositoryFromProjectInput!`): Parameters for + UnlinkRepositoryFromProject + """ + + unlock_lockable = sgqlc.types.Field( + "UnlockLockablePayload", + graphql_name="unlockLockable", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnlockLockableInput), graphql_name="input", default=None)),) + ), + ) + """Unlock a lockable object + + Arguments: + + * `input` (`UnlockLockableInput!`): Parameters for UnlockLockable + """ + + unmark_discussion_comment_as_answer = sgqlc.types.Field( + "UnmarkDiscussionCommentAsAnswerPayload", + graphql_name="unmarkDiscussionCommentAsAnswer", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnmarkDiscussionCommentAsAnswerInput), graphql_name="input", default=None)),) + ), + ) + """Unmark a discussion comment as the chosen answer for discussions + in an answerable category. + + Arguments: + + * `input` (`UnmarkDiscussionCommentAsAnswerInput!`): Parameters + for UnmarkDiscussionCommentAsAnswer + """ + + unmark_file_as_viewed = sgqlc.types.Field( + "UnmarkFileAsViewedPayload", + graphql_name="unmarkFileAsViewed", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnmarkFileAsViewedInput), graphql_name="input", default=None)),) + ), + ) + """Unmark a pull request file as viewed + + Arguments: + + * `input` (`UnmarkFileAsViewedInput!`): Parameters for + UnmarkFileAsViewed + """ + + unmark_issue_as_duplicate = sgqlc.types.Field( + "UnmarkIssueAsDuplicatePayload", + graphql_name="unmarkIssueAsDuplicate", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnmarkIssueAsDuplicateInput), graphql_name="input", default=None)),) + ), + ) + """Unmark an issue as a duplicate of another issue. + + Arguments: + + * `input` (`UnmarkIssueAsDuplicateInput!`): Parameters for + UnmarkIssueAsDuplicate + """ + + unminimize_comment = sgqlc.types.Field( + "UnminimizeCommentPayload", + graphql_name="unminimizeComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnminimizeCommentInput), graphql_name="input", default=None)),) + ), + ) + """Unminimizes a comment on an Issue, Commit, Pull Request, or Gist + + Arguments: + + * `input` (`UnminimizeCommentInput!`): Parameters for + UnminimizeComment + """ + + unpin_issue = sgqlc.types.Field( + "UnpinIssuePayload", + graphql_name="unpinIssue", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(UnpinIssueInput), graphql_name="input", default=None)),)), + ) + """Unpin a pinned issue from a repository + + Arguments: + + * `input` (`UnpinIssueInput!`): Parameters for UnpinIssue + """ + + unresolve_review_thread = sgqlc.types.Field( + "UnresolveReviewThreadPayload", + graphql_name="unresolveReviewThread", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UnresolveReviewThreadInput), graphql_name="input", default=None)),) + ), + ) + """Marks a review thread as unresolved. + + Arguments: + + * `input` (`UnresolveReviewThreadInput!`): Parameters for + UnresolveReviewThread + """ + + update_branch_protection_rule = sgqlc.types.Field( + "UpdateBranchProtectionRulePayload", + graphql_name="updateBranchProtectionRule", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateBranchProtectionRuleInput), graphql_name="input", default=None)),) + ), + ) + """Create a new branch protection rule + + Arguments: + + * `input` (`UpdateBranchProtectionRuleInput!`): Parameters for + UpdateBranchProtectionRule + """ + + update_check_run = sgqlc.types.Field( + "UpdateCheckRunPayload", + graphql_name="updateCheckRun", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateCheckRunInput), graphql_name="input", default=None)),) + ), + ) + """Update a check run + + Arguments: + + * `input` (`UpdateCheckRunInput!`): Parameters for UpdateCheckRun + """ + + update_check_suite_preferences = sgqlc.types.Field( + "UpdateCheckSuitePreferencesPayload", + graphql_name="updateCheckSuitePreferences", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateCheckSuitePreferencesInput), graphql_name="input", default=None)),) + ), + ) + """Modifies the settings of an existing check suite + + Arguments: + + * `input` (`UpdateCheckSuitePreferencesInput!`): Parameters for + UpdateCheckSuitePreferences + """ + + update_discussion = sgqlc.types.Field( + "UpdateDiscussionPayload", + graphql_name="updateDiscussion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateDiscussionInput), graphql_name="input", default=None)),) + ), + ) + """Update a discussion + + Arguments: + + * `input` (`UpdateDiscussionInput!`): Parameters for + UpdateDiscussion + """ + + update_discussion_comment = sgqlc.types.Field( + "UpdateDiscussionCommentPayload", + graphql_name="updateDiscussionComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateDiscussionCommentInput), graphql_name="input", default=None)),) + ), + ) + """Update the contents of a comment on a Discussion + + Arguments: + + * `input` (`UpdateDiscussionCommentInput!`): Parameters for + UpdateDiscussionComment + """ + + update_enterprise_administrator_role = sgqlc.types.Field( + "UpdateEnterpriseAdministratorRolePayload", + graphql_name="updateEnterpriseAdministratorRole", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateEnterpriseAdministratorRoleInput), graphql_name="input", default=None)),) + ), + ) + """Updates the role of an enterprise administrator. + + Arguments: + + * `input` (`UpdateEnterpriseAdministratorRoleInput!`): Parameters + for UpdateEnterpriseAdministratorRole + """ + + update_enterprise_allow_private_repository_forking_setting = sgqlc.types.Field( + "UpdateEnterpriseAllowPrivateRepositoryForkingSettingPayload", + graphql_name="updateEnterpriseAllowPrivateRepositoryForkingSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseAllowPrivateRepositoryForkingSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets whether private repository forks are enabled for an + enterprise. + + Arguments: + + * `input` + (`UpdateEnterpriseAllowPrivateRepositoryForkingSettingInput!`): + Parameters for + UpdateEnterpriseAllowPrivateRepositoryForkingSetting + """ + + update_enterprise_default_repository_permission_setting = sgqlc.types.Field( + "UpdateEnterpriseDefaultRepositoryPermissionSettingPayload", + graphql_name="updateEnterpriseDefaultRepositoryPermissionSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseDefaultRepositoryPermissionSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets the base repository permission for organizations in an + enterprise. + + Arguments: + + * `input` + (`UpdateEnterpriseDefaultRepositoryPermissionSettingInput!`): + Parameters for + UpdateEnterpriseDefaultRepositoryPermissionSetting + """ + + update_enterprise_members_can_change_repository_visibility_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingPayload", + graphql_name="updateEnterpriseMembersCanChangeRepositoryVisibilitySetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingInput), + graphql_name="input", + default=None, + ), + ), + ) + ), + ) + """Sets whether organization members with admin permissions on a + repository can change repository visibility. + + Arguments: + + * `input` (`UpdateEnterpriseMembersCanChangeRepositoryVisibilitySe + ttingInput!`): Parameters for + UpdateEnterpriseMembersCanChangeRepositoryVisibilitySetting + """ + + update_enterprise_members_can_create_repositories_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanCreateRepositoriesSettingPayload", + graphql_name="updateEnterpriseMembersCanCreateRepositoriesSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanCreateRepositoriesSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets the members can create repositories setting for an + enterprise. + + Arguments: + + * `input` + (`UpdateEnterpriseMembersCanCreateRepositoriesSettingInput!`): + Parameters for + UpdateEnterpriseMembersCanCreateRepositoriesSetting + """ + + update_enterprise_members_can_delete_issues_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanDeleteIssuesSettingPayload", + graphql_name="updateEnterpriseMembersCanDeleteIssuesSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanDeleteIssuesSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets the members can delete issues setting for an enterprise. + + Arguments: + + * `input` (`UpdateEnterpriseMembersCanDeleteIssuesSettingInput!`): + Parameters for UpdateEnterpriseMembersCanDeleteIssuesSetting + """ + + update_enterprise_members_can_delete_repositories_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanDeleteRepositoriesSettingPayload", + graphql_name="updateEnterpriseMembersCanDeleteRepositoriesSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanDeleteRepositoriesSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets the members can delete repositories setting for an + enterprise. + + Arguments: + + * `input` + (`UpdateEnterpriseMembersCanDeleteRepositoriesSettingInput!`): + Parameters for + UpdateEnterpriseMembersCanDeleteRepositoriesSetting + """ + + update_enterprise_members_can_invite_collaborators_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanInviteCollaboratorsSettingPayload", + graphql_name="updateEnterpriseMembersCanInviteCollaboratorsSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanInviteCollaboratorsSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets whether members can invite collaborators are enabled for an + enterprise. + + Arguments: + + * `input` + (`UpdateEnterpriseMembersCanInviteCollaboratorsSettingInput!`): + Parameters for + UpdateEnterpriseMembersCanInviteCollaboratorsSetting + """ + + update_enterprise_members_can_make_purchases_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanMakePurchasesSettingPayload", + graphql_name="updateEnterpriseMembersCanMakePurchasesSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanMakePurchasesSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets whether or not an organization admin can make purchases. + + Arguments: + + * `input` + (`UpdateEnterpriseMembersCanMakePurchasesSettingInput!`): + Parameters for UpdateEnterpriseMembersCanMakePurchasesSetting + """ + + update_enterprise_members_can_update_protected_branches_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanUpdateProtectedBranchesSettingPayload", + graphql_name="updateEnterpriseMembersCanUpdateProtectedBranchesSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanUpdateProtectedBranchesSettingInput), + graphql_name="input", + default=None, + ), + ), + ) + ), + ) + """Sets the members can update protected branches setting for an + enterprise. + + Arguments: + + * `input` (`UpdateEnterpriseMembersCanUpdateProtectedBranchesSetti + ngInput!`): Parameters for + UpdateEnterpriseMembersCanUpdateProtectedBranchesSetting + """ + + update_enterprise_members_can_view_dependency_insights_setting = sgqlc.types.Field( + "UpdateEnterpriseMembersCanViewDependencyInsightsSettingPayload", + graphql_name="updateEnterpriseMembersCanViewDependencyInsightsSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseMembersCanViewDependencyInsightsSettingInput), + graphql_name="input", + default=None, + ), + ), + ) + ), + ) + """Sets the members can view dependency insights for an enterprise. + + Arguments: + + * `input` (`UpdateEnterpriseMembersCanViewDependencyInsightsSettin + gInput!`): Parameters for + UpdateEnterpriseMembersCanViewDependencyInsightsSetting + """ + + update_enterprise_organization_projects_setting = sgqlc.types.Field( + "UpdateEnterpriseOrganizationProjectsSettingPayload", + graphql_name="updateEnterpriseOrganizationProjectsSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseOrganizationProjectsSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets whether organization projects are enabled for an enterprise. + + Arguments: + + * `input` (`UpdateEnterpriseOrganizationProjectsSettingInput!`): + Parameters for UpdateEnterpriseOrganizationProjectsSetting + """ + + update_enterprise_owner_organization_role = sgqlc.types.Field( + "UpdateEnterpriseOwnerOrganizationRolePayload", + graphql_name="updateEnterpriseOwnerOrganizationRole", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg(sgqlc.types.non_null(UpdateEnterpriseOwnerOrganizationRoleInput), graphql_name="input", default=None), + ), + ) + ), + ) + """Updates the role of an enterprise owner with an organization. + + Arguments: + + * `input` (`UpdateEnterpriseOwnerOrganizationRoleInput!`): + Parameters for UpdateEnterpriseOwnerOrganizationRole + """ + + update_enterprise_profile = sgqlc.types.Field( + "UpdateEnterpriseProfilePayload", + graphql_name="updateEnterpriseProfile", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateEnterpriseProfileInput), graphql_name="input", default=None)),) + ), + ) + """Updates an enterprise's profile. + + Arguments: + + * `input` (`UpdateEnterpriseProfileInput!`): Parameters for + UpdateEnterpriseProfile + """ + + update_enterprise_repository_projects_setting = sgqlc.types.Field( + "UpdateEnterpriseRepositoryProjectsSettingPayload", + graphql_name="updateEnterpriseRepositoryProjectsSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseRepositoryProjectsSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets whether repository projects are enabled for a enterprise. + + Arguments: + + * `input` (`UpdateEnterpriseRepositoryProjectsSettingInput!`): + Parameters for UpdateEnterpriseRepositoryProjectsSetting + """ + + update_enterprise_team_discussions_setting = sgqlc.types.Field( + "UpdateEnterpriseTeamDiscussionsSettingPayload", + graphql_name="updateEnterpriseTeamDiscussionsSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg(sgqlc.types.non_null(UpdateEnterpriseTeamDiscussionsSettingInput), graphql_name="input", default=None), + ), + ) + ), + ) + """Sets whether team discussions are enabled for an enterprise. + + Arguments: + + * `input` (`UpdateEnterpriseTeamDiscussionsSettingInput!`): + Parameters for UpdateEnterpriseTeamDiscussionsSetting + """ + + update_enterprise_two_factor_authentication_required_setting = sgqlc.types.Field( + "UpdateEnterpriseTwoFactorAuthenticationRequiredSettingPayload", + graphql_name="updateEnterpriseTwoFactorAuthenticationRequiredSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateEnterpriseTwoFactorAuthenticationRequiredSettingInput), + graphql_name="input", + default=None, + ), + ), + ) + ), + ) + """Sets whether two factor authentication is required for all users + in an enterprise. + + Arguments: + + * `input` (`UpdateEnterpriseTwoFactorAuthenticationRequiredSetting + Input!`): Parameters for + UpdateEnterpriseTwoFactorAuthenticationRequiredSetting + """ + + update_environment = sgqlc.types.Field( + "UpdateEnvironmentPayload", + graphql_name="updateEnvironment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateEnvironmentInput), graphql_name="input", default=None)),) + ), + ) + """Updates an environment. + + Arguments: + + * `input` (`UpdateEnvironmentInput!`): Parameters for + UpdateEnvironment + """ + + update_ip_allow_list_enabled_setting = sgqlc.types.Field( + "UpdateIpAllowListEnabledSettingPayload", + graphql_name="updateIpAllowListEnabledSetting", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateIpAllowListEnabledSettingInput), graphql_name="input", default=None)),) + ), + ) + """Sets whether an IP allow list is enabled on an owner. + + Arguments: + + * `input` (`UpdateIpAllowListEnabledSettingInput!`): Parameters + for UpdateIpAllowListEnabledSetting + """ + + update_ip_allow_list_entry = sgqlc.types.Field( + "UpdateIpAllowListEntryPayload", + graphql_name="updateIpAllowListEntry", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateIpAllowListEntryInput), graphql_name="input", default=None)),) + ), + ) + """Updates an IP allow list entry. + + Arguments: + + * `input` (`UpdateIpAllowListEntryInput!`): Parameters for + UpdateIpAllowListEntry + """ + + update_ip_allow_list_for_installed_apps_enabled_setting = sgqlc.types.Field( + "UpdateIpAllowListForInstalledAppsEnabledSettingPayload", + graphql_name="updateIpAllowListForInstalledAppsEnabledSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateIpAllowListForInstalledAppsEnabledSettingInput), graphql_name="input", default=None + ), + ), + ) + ), + ) + """Sets whether IP allow list configuration for installed GitHub Apps + is enabled on an owner. + + Arguments: + + * `input` + (`UpdateIpAllowListForInstalledAppsEnabledSettingInput!`): + Parameters for UpdateIpAllowListForInstalledAppsEnabledSetting + """ + + update_issue = sgqlc.types.Field( + "UpdateIssuePayload", + graphql_name="updateIssue", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateIssueInput), graphql_name="input", default=None)),)), + ) + """Updates an Issue. + + Arguments: + + * `input` (`UpdateIssueInput!`): Parameters for UpdateIssue + """ + + update_issue_comment = sgqlc.types.Field( + "UpdateIssueCommentPayload", + graphql_name="updateIssueComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateIssueCommentInput), graphql_name="input", default=None)),) + ), + ) + """Updates an IssueComment object. + + Arguments: + + * `input` (`UpdateIssueCommentInput!`): Parameters for + UpdateIssueComment + """ + + update_notification_restriction_setting = sgqlc.types.Field( + "UpdateNotificationRestrictionSettingPayload", + graphql_name="updateNotificationRestrictionSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg(sgqlc.types.non_null(UpdateNotificationRestrictionSettingInput), graphql_name="input", default=None), + ), + ) + ), + ) + """Update the setting to restrict notifications to only verified or + approved domains available to an owner. + + Arguments: + + * `input` (`UpdateNotificationRestrictionSettingInput!`): + Parameters for UpdateNotificationRestrictionSetting + """ + + update_organization_allow_private_repository_forking_setting = sgqlc.types.Field( + "UpdateOrganizationAllowPrivateRepositoryForkingSettingPayload", + graphql_name="updateOrganizationAllowPrivateRepositoryForkingSetting", + args=sgqlc.types.ArgDict( + ( + ( + "input", + sgqlc.types.Arg( + sgqlc.types.non_null(UpdateOrganizationAllowPrivateRepositoryForkingSettingInput), + graphql_name="input", + default=None, + ), + ), + ) + ), + ) + """Sets whether private repository forks are enabled for an + organization. + + Arguments: + + * `input` (`UpdateOrganizationAllowPrivateRepositoryForkingSetting + Input!`): Parameters for + UpdateOrganizationAllowPrivateRepositoryForkingSetting + """ + + update_project = sgqlc.types.Field( + "UpdateProjectPayload", + graphql_name="updateProject", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateProjectInput), graphql_name="input", default=None)),) + ), + ) + """Updates an existing project. + + Arguments: + + * `input` (`UpdateProjectInput!`): Parameters for UpdateProject + """ + + update_project_card = sgqlc.types.Field( + "UpdateProjectCardPayload", + graphql_name="updateProjectCard", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateProjectCardInput), graphql_name="input", default=None)),) + ), + ) + """Updates an existing project card. + + Arguments: + + * `input` (`UpdateProjectCardInput!`): Parameters for + UpdateProjectCard + """ + + update_project_column = sgqlc.types.Field( + "UpdateProjectColumnPayload", + graphql_name="updateProjectColumn", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateProjectColumnInput), graphql_name="input", default=None)),) + ), + ) + """Updates an existing project column. + + Arguments: + + * `input` (`UpdateProjectColumnInput!`): Parameters for + UpdateProjectColumn + """ + + update_project_draft_issue = sgqlc.types.Field( + "UpdateProjectDraftIssuePayload", + graphql_name="updateProjectDraftIssue", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateProjectDraftIssueInput), graphql_name="input", default=None)),) + ), + ) + """Updates a draft issue within a Project. + + Arguments: + + * `input` (`UpdateProjectDraftIssueInput!`): Parameters for + UpdateProjectDraftIssue + """ + + update_project_next = sgqlc.types.Field( + "UpdateProjectNextPayload", + graphql_name="updateProjectNext", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateProjectNextInput), graphql_name="input", default=None)),) + ), + ) + """Updates an existing project (beta). + + Arguments: + + * `input` (`UpdateProjectNextInput!`): Parameters for + UpdateProjectNext + """ + + update_project_next_item_field = sgqlc.types.Field( + "UpdateProjectNextItemFieldPayload", + graphql_name="updateProjectNextItemField", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateProjectNextItemFieldInput), graphql_name="input", default=None)),) + ), + ) + """Updates a field of an item from a Project. + + Arguments: + + * `input` (`UpdateProjectNextItemFieldInput!`): Parameters for + UpdateProjectNextItemField + """ + + update_pull_request = sgqlc.types.Field( + "UpdatePullRequestPayload", + graphql_name="updatePullRequest", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdatePullRequestInput), graphql_name="input", default=None)),) + ), + ) + """Update a pull request + + Arguments: + + * `input` (`UpdatePullRequestInput!`): Parameters for + UpdatePullRequest + """ + + update_pull_request_branch = sgqlc.types.Field( + "UpdatePullRequestBranchPayload", + graphql_name="updatePullRequestBranch", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdatePullRequestBranchInput), graphql_name="input", default=None)),) + ), + ) + """Merge or Rebase HEAD from upstream branch into pull request branch + + Arguments: + + * `input` (`UpdatePullRequestBranchInput!`): Parameters for + UpdatePullRequestBranch + """ + + update_pull_request_review = sgqlc.types.Field( + "UpdatePullRequestReviewPayload", + graphql_name="updatePullRequestReview", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdatePullRequestReviewInput), graphql_name="input", default=None)),) + ), + ) + """Updates the body of a pull request review. + + Arguments: + + * `input` (`UpdatePullRequestReviewInput!`): Parameters for + UpdatePullRequestReview + """ + + update_pull_request_review_comment = sgqlc.types.Field( + "UpdatePullRequestReviewCommentPayload", + graphql_name="updatePullRequestReviewComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdatePullRequestReviewCommentInput), graphql_name="input", default=None)),) + ), + ) + """Updates a pull request review comment. + + Arguments: + + * `input` (`UpdatePullRequestReviewCommentInput!`): Parameters for + UpdatePullRequestReviewComment + """ + + update_ref = sgqlc.types.Field( + "UpdateRefPayload", + graphql_name="updateRef", + args=sgqlc.types.ArgDict((("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateRefInput), graphql_name="input", default=None)),)), + ) + """Update a Git Ref. + + Arguments: + + * `input` (`UpdateRefInput!`): Parameters for UpdateRef + """ + + update_repository = sgqlc.types.Field( + "UpdateRepositoryPayload", + graphql_name="updateRepository", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateRepositoryInput), graphql_name="input", default=None)),) + ), + ) + """Update information about a repository. + + Arguments: + + * `input` (`UpdateRepositoryInput!`): Parameters for + UpdateRepository + """ + + update_sponsorship_preferences = sgqlc.types.Field( + "UpdateSponsorshipPreferencesPayload", + graphql_name="updateSponsorshipPreferences", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateSponsorshipPreferencesInput), graphql_name="input", default=None)),) + ), + ) + """Change visibility of your sponsorship and opt in or out of email + updates from the maintainer. + + Arguments: + + * `input` (`UpdateSponsorshipPreferencesInput!`): Parameters for + UpdateSponsorshipPreferences + """ + + update_subscription = sgqlc.types.Field( + "UpdateSubscriptionPayload", + graphql_name="updateSubscription", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateSubscriptionInput), graphql_name="input", default=None)),) + ), + ) + """Updates the state for subscribable subjects. + + Arguments: + + * `input` (`UpdateSubscriptionInput!`): Parameters for + UpdateSubscription + """ + + update_team_discussion = sgqlc.types.Field( + "UpdateTeamDiscussionPayload", + graphql_name="updateTeamDiscussion", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateTeamDiscussionInput), graphql_name="input", default=None)),) + ), + ) + """Updates a team discussion. + + Arguments: + + * `input` (`UpdateTeamDiscussionInput!`): Parameters for + UpdateTeamDiscussion + """ + + update_team_discussion_comment = sgqlc.types.Field( + "UpdateTeamDiscussionCommentPayload", + graphql_name="updateTeamDiscussionComment", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateTeamDiscussionCommentInput), graphql_name="input", default=None)),) + ), + ) + """Updates a discussion comment. + + Arguments: + + * `input` (`UpdateTeamDiscussionCommentInput!`): Parameters for + UpdateTeamDiscussionComment + """ + + update_teams_repository = sgqlc.types.Field( + "UpdateTeamsRepositoryPayload", + graphql_name="updateTeamsRepository", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateTeamsRepositoryInput), graphql_name="input", default=None)),) + ), + ) + """Update team repository. + + Arguments: + + * `input` (`UpdateTeamsRepositoryInput!`): Parameters for + UpdateTeamsRepository + """ + + update_topics = sgqlc.types.Field( + "UpdateTopicsPayload", + graphql_name="updateTopics", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(UpdateTopicsInput), graphql_name="input", default=None)),) + ), + ) + """Replaces the repository's topics with the given topics. + + Arguments: + + * `input` (`UpdateTopicsInput!`): Parameters for UpdateTopics + """ + + verify_verifiable_domain = sgqlc.types.Field( + "VerifyVerifiableDomainPayload", + graphql_name="verifyVerifiableDomain", + args=sgqlc.types.ArgDict( + (("input", sgqlc.types.Arg(sgqlc.types.non_null(VerifyVerifiableDomainInput), graphql_name="input", default=None)),) + ), + ) + """Verify that a verifiable domain has the expected DNS record. + + Arguments: + + * `input` (`VerifyVerifiableDomainInput!`): Parameters for + VerifyVerifiableDomain + """ + + +class Node(sgqlc.types.Interface): + """An object with an ID.""" + + __schema__ = github_schema + __field_names__ = ("id",) + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + """ID of the object.""" + + +class OauthApplicationAuditEntryData(sgqlc.types.Interface): + """Metadata for an audit entry with action oauth_application.*""" + + __schema__ = github_schema + __field_names__ = ("oauth_application_name", "oauth_application_resource_path", "oauth_application_url") + oauth_application_name = sgqlc.types.Field(String, graphql_name="oauthApplicationName") + """The name of the OAuth Application.""" + + oauth_application_resource_path = sgqlc.types.Field(URI, graphql_name="oauthApplicationResourcePath") + """The HTTP path for the OAuth Application""" + + oauth_application_url = sgqlc.types.Field(URI, graphql_name="oauthApplicationUrl") + """The HTTP URL for the OAuth Application""" + + +class OrganizationAuditEntryConnection(sgqlc.types.relay.Connection): + """The connection type for OrganizationAuditEntry.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("OrganizationAuditEntryEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("OrganizationAuditEntry"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class OrganizationAuditEntryData(sgqlc.types.Interface): + """Metadata for an audit entry with action org.*""" + + __schema__ = github_schema + __field_names__ = ("organization", "organization_name", "organization_resource_path", "organization_url") + organization = sgqlc.types.Field("Organization", graphql_name="organization") + """The Organization associated with the Audit Entry.""" + + organization_name = sgqlc.types.Field(String, graphql_name="organizationName") + """The name of the Organization.""" + + organization_resource_path = sgqlc.types.Field(URI, graphql_name="organizationResourcePath") + """The HTTP path for the organization""" + + organization_url = sgqlc.types.Field(URI, graphql_name="organizationUrl") + """The HTTP URL for the organization""" + + +class OrganizationAuditEntryEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("OrganizationAuditEntry", graphql_name="node") + """The item at the end of the edge.""" + + +class OrganizationConnection(sgqlc.types.relay.Connection): + """A list of organizations managed by an enterprise.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("OrganizationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Organization"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class OrganizationEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Organization", graphql_name="node") + """The item at the end of the edge.""" + + +class OrganizationEnterpriseOwnerConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("OrganizationEnterpriseOwnerEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class OrganizationEnterpriseOwnerEdge(sgqlc.types.Type): + """An enterprise owner in the context of an organization that is part + of the enterprise. + """ + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "organization_role") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("User", graphql_name="node") + """The item at the end of the edge.""" + + organization_role = sgqlc.types.Field(sgqlc.types.non_null(RoleInOrganization), graphql_name="organizationRole") + """The role of the owner with respect to the organization.""" + + +class OrganizationInvitationConnection(sgqlc.types.relay.Connection): + """The connection type for OrganizationInvitation.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("OrganizationInvitationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("OrganizationInvitation"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class OrganizationInvitationEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("OrganizationInvitation", graphql_name="node") + """The item at the end of the edge.""" + + +class OrganizationMemberConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("OrganizationMemberEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class OrganizationMemberEdge(sgqlc.types.Type): + """Represents a user within an organization.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "has_two_factor_enabled", "node", "role") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + has_two_factor_enabled = sgqlc.types.Field(Boolean, graphql_name="hasTwoFactorEnabled") + """Whether the organization member has two factor enabled or not. + Returns null if information is not available to viewer. + """ + + node = sgqlc.types.Field("User", graphql_name="node") + """The item at the end of the edge.""" + + role = sgqlc.types.Field(OrganizationMemberRole, graphql_name="role") + """The role this user has in the organization.""" + + +class PackageConnection(sgqlc.types.relay.Connection): + """The connection type for Package.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PackageEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Package"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PackageEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Package", graphql_name="node") + """The item at the end of the edge.""" + + +class PackageFileConnection(sgqlc.types.relay.Connection): + """The connection type for PackageFile.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PackageFileEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PackageFile"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PackageFileEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PackageFile", graphql_name="node") + """The item at the end of the edge.""" + + +class PackageOwner(sgqlc.types.Interface): + """Represents an owner of a package.""" + + __schema__ = github_schema + __field_names__ = ("id", "packages") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + packages = sgqlc.types.Field( + sgqlc.types.non_null(PackageConnection), + graphql_name="packages", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("names", sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="names", default=None)), + ("repository_id", sgqlc.types.Arg(ID, graphql_name="repositoryId", default=None)), + ("package_type", sgqlc.types.Arg(PackageType, graphql_name="packageType", default=None)), + ("order_by", sgqlc.types.Arg(PackageOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "DESC"})), + ) + ), + ) + """A list of packages under the owner. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `names` (`[String]`): Find packages by their names. + * `repository_id` (`ID`): Find packages in a repository by ID. + * `package_type` (`PackageType`): Filter registry package by type. + * `order_by` (`PackageOrder`): Ordering of the returned packages. + (default: `{field: CREATED_AT, direction: DESC}`) + """ + + +class PackageStatistics(sgqlc.types.Type): + """Represents a object that contains package activity statistics such + as downloads. + """ + + __schema__ = github_schema + __field_names__ = ("downloads_total_count",) + downloads_total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="downloadsTotalCount") + """Number of times the package was downloaded since it was created.""" + + +class PackageVersionConnection(sgqlc.types.relay.Connection): + """The connection type for PackageVersion.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PackageVersionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PackageVersion"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null("PageInfo"), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PackageVersionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PackageVersion", graphql_name="node") + """The item at the end of the edge.""" + + +class PackageVersionStatistics(sgqlc.types.Type): + """Represents a object that contains package version activity + statistics such as downloads. + """ + + __schema__ = github_schema + __field_names__ = ("downloads_total_count",) + downloads_total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="downloadsTotalCount") + """Number of times the package was downloaded since it was created.""" + + +class PageInfo(sgqlc.types.Type): + """Information about pagination in a connection.""" + + __schema__ = github_schema + __field_names__ = ("end_cursor", "has_next_page", "has_previous_page", "start_cursor") + end_cursor = sgqlc.types.Field(String, graphql_name="endCursor") + """When paginating forwards, the cursor to continue.""" + + has_next_page = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasNextPage") + """When paginating forwards, are there more items?""" + + has_previous_page = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasPreviousPage") + """When paginating backwards, are there more items?""" + + start_cursor = sgqlc.types.Field(String, graphql_name="startCursor") + """When paginating backwards, the cursor to continue.""" + + +class PermissionSource(sgqlc.types.Type): + """A level of permission and source for a user's access to a + repository. + """ + + __schema__ = github_schema + __field_names__ = ("organization", "permission", "source") + organization = sgqlc.types.Field(sgqlc.types.non_null("Organization"), graphql_name="organization") + """The organization the repository belongs to.""" + + permission = sgqlc.types.Field(sgqlc.types.non_null(DefaultRepositoryPermissionField), graphql_name="permission") + """The level of access this source has granted to the user.""" + + source = sgqlc.types.Field(sgqlc.types.non_null("PermissionGranter"), graphql_name="source") + """The source of this permission.""" + + +class PinIssuePayload(sgqlc.types.Type): + """Autogenerated return type of PinIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "issue") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue = sgqlc.types.Field("Issue", graphql_name="issue") + """The issue that was pinned""" + + +class PinnableItemConnection(sgqlc.types.relay.Connection): + """The connection type for PinnableItem.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PinnableItemEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PinnableItem"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PinnableItemEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PinnableItem", graphql_name="node") + """The item at the end of the edge.""" + + +class PinnedDiscussionConnection(sgqlc.types.relay.Connection): + """The connection type for PinnedDiscussion.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PinnedDiscussionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PinnedDiscussion"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PinnedDiscussionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PinnedDiscussion", graphql_name="node") + """The item at the end of the edge.""" + + +class PinnedIssueConnection(sgqlc.types.relay.Connection): + """The connection type for PinnedIssue.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PinnedIssueEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PinnedIssue"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PinnedIssueEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PinnedIssue", graphql_name="node") + """The item at the end of the edge.""" + + +class ProfileItemShowcase(sgqlc.types.Type): + """A curatable list of repositories relating to a repository owner, + which defaults to showing the most popular repositories they own. + """ + + __schema__ = github_schema + __field_names__ = ("has_pinned_items", "items") + has_pinned_items = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasPinnedItems") + """Whether or not the owner has pinned any repositories or gists.""" + + items = sgqlc.types.Field( + sgqlc.types.non_null(PinnableItemConnection), + graphql_name="items", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The repositories and gists in the showcase. If the profile owner + has any pinned items, those will be returned. Otherwise, the + profile owner's popular repositories will be returned. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class ProfileOwner(sgqlc.types.Interface): + """Represents any entity on GitHub that has a profile page.""" + + __schema__ = github_schema + __field_names__ = ( + "any_pinnable_items", + "email", + "id", + "item_showcase", + "location", + "login", + "name", + "pinnable_items", + "pinned_items", + "pinned_items_remaining", + "viewer_can_change_pinned_items", + "website_url", + ) + any_pinnable_items = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), + graphql_name="anyPinnableItems", + args=sgqlc.types.ArgDict((("type", sgqlc.types.Arg(PinnableItemType, graphql_name="type", default=None)),)), + ) + """Determine if this repository owner has any items that can be + pinned to their profile. + + Arguments: + + * `type` (`PinnableItemType`): Filter to only a particular kind of + pinnable item. + """ + + email = sgqlc.types.Field(String, graphql_name="email") + """The public profile email.""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + item_showcase = sgqlc.types.Field(sgqlc.types.non_null(ProfileItemShowcase), graphql_name="itemShowcase") + """Showcases a selection of repositories and gists that the profile + owner has either curated or that have been selected automatically + based on popularity. + """ + + location = sgqlc.types.Field(String, graphql_name="location") + """The public profile location.""" + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The username used to login.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The public profile name.""" + + pinnable_items = sgqlc.types.Field( + sgqlc.types.non_null(PinnableItemConnection), + graphql_name="pinnableItems", + args=sgqlc.types.ArgDict( + ( + ("types", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PinnableItemType)), graphql_name="types", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of repositories and gists this profile owner can pin to + their profile. + + Arguments: + + * `types` (`[PinnableItemType!]`): Filter the types of pinnable + items that are returned. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pinned_items = sgqlc.types.Field( + sgqlc.types.non_null(PinnableItemConnection), + graphql_name="pinnedItems", + args=sgqlc.types.ArgDict( + ( + ("types", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PinnableItemType)), graphql_name="types", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of repositories and gists this profile owner has pinned to + their profile + + Arguments: + + * `types` (`[PinnableItemType!]`): Filter the types of pinned + items that are returned. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pinned_items_remaining = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="pinnedItemsRemaining") + """Returns how many more items this profile owner can pin to their + profile. + """ + + viewer_can_change_pinned_items = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanChangePinnedItems") + """Can the viewer pin repositories and gists to the profile?""" + + website_url = sgqlc.types.Field(URI, graphql_name="websiteUrl") + """The public profile website URL.""" + + +class ProjectCardConnection(sgqlc.types.relay.Connection): + """The connection type for ProjectCard.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectCardEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ProjectCard"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectCardEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ProjectCard", graphql_name="node") + """The item at the end of the edge.""" + + +class ProjectColumnConnection(sgqlc.types.relay.Connection): + """The connection type for ProjectColumn.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectColumnEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ProjectColumn"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectColumnEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ProjectColumn", graphql_name="node") + """The item at the end of the edge.""" + + +class ProjectConnection(sgqlc.types.relay.Connection): + """A list of projects associated with the owner.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Project"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Project", graphql_name="node") + """The item at the end of the edge.""" + + +class ProjectNextConnection(sgqlc.types.relay.Connection): + """The connection type for ProjectNext.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectNextEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ProjectNext"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectNextEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ProjectNext", graphql_name="node") + """The item at the end of the edge.""" + + +class ProjectNextFieldCommon(sgqlc.types.Interface): + """Common fields across different field types""" + + __schema__ = github_schema + __field_names__ = ("created_at", "data_type", "database_id", "id", "name", "project", "settings", "updated_at") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + data_type = sgqlc.types.Field(sgqlc.types.non_null(ProjectNextFieldType), graphql_name="dataType") + """The field's type.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The project field's name.""" + + project = sgqlc.types.Field(sgqlc.types.non_null("ProjectNext"), graphql_name="project") + """The project that contains this field.""" + + settings = sgqlc.types.Field(String, graphql_name="settings") + """The field's settings.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class ProjectNextFieldConnection(sgqlc.types.relay.Connection): + """The connection type for ProjectNextField.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectNextFieldEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ProjectNextField"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectNextFieldEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ProjectNextField", graphql_name="node") + """The item at the end of the edge.""" + + +class ProjectNextItemConnection(sgqlc.types.relay.Connection): + """The connection type for ProjectNextItem.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectNextItemEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ProjectNextItem"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectNextItemEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ProjectNextItem", graphql_name="node") + """The item at the end of the edge.""" + + +class ProjectNextItemFieldValueConnection(sgqlc.types.relay.Connection): + """The connection type for ProjectNextItemFieldValue.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectNextItemFieldValueEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ProjectNextItemFieldValue"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectNextItemFieldValueEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ProjectNextItemFieldValue", graphql_name="node") + """The item at the end of the edge.""" + + +class ProjectNextOwner(sgqlc.types.Interface): + """Represents an owner of a project (beta).""" + + __schema__ = github_schema + __field_names__ = ("id", "project_next", "projects_next") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + project_next = sgqlc.types.Field( + "ProjectNext", + graphql_name="projectNext", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Find a project by project (beta) number. + + Arguments: + + * `number` (`Int!`): The project (beta) number. + """ + + projects_next = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextConnection), + graphql_name="projectsNext", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("sort_by", sgqlc.types.Arg(ProjectNextOrderField, graphql_name="sortBy", default="TITLE")), + ) + ), + ) + """A list of projects (beta) under the owner. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `query` (`String`): A project (beta) to search for under the the + owner. + * `sort_by` (`ProjectNextOrderField`): How to order the returned + projects (beta). (default: `TITLE`) + """ + + +class ProjectOwner(sgqlc.types.Interface): + """Represents an owner of a Project.""" + + __schema__ = github_schema + __field_names__ = ("id", "project", "projects", "projects_resource_path", "projects_url", "viewer_can_create_projects") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + project = sgqlc.types.Field( + "Project", + graphql_name="project", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Find project by number. + + Arguments: + + * `number` (`Int!`): The project number to find. + """ + + projects = sgqlc.types.Field( + sgqlc.types.non_null(ProjectConnection), + graphql_name="projects", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(ProjectOrder, graphql_name="orderBy", default=None)), + ("search", sgqlc.types.Arg(String, graphql_name="search", default=None)), + ("states", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(ProjectState)), graphql_name="states", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of projects under the owner. + + Arguments: + + * `order_by` (`ProjectOrder`): Ordering options for projects + returned from the connection + * `search` (`String`): Query to search projects by, currently only + searching by name. + * `states` (`[ProjectState!]`): A list of states to filter the + projects by. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + projects_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="projectsResourcePath") + """The HTTP path listing owners projects""" + + projects_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="projectsUrl") + """The HTTP URL listing owners projects""" + + viewer_can_create_projects = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanCreateProjects") + """Can the current viewer create new projects on this owner.""" + + +class ProjectProgress(sgqlc.types.Type): + """Project progress stats.""" + + __schema__ = github_schema + __field_names__ = ( + "done_count", + "done_percentage", + "enabled", + "in_progress_count", + "in_progress_percentage", + "todo_count", + "todo_percentage", + ) + done_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="doneCount") + """The number of done cards.""" + + done_percentage = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="donePercentage") + """The percentage of done cards.""" + + enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="enabled") + """Whether progress tracking is enabled and cards with purpose exist + for this project + """ + + in_progress_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="inProgressCount") + """The number of in-progress cards.""" + + in_progress_percentage = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="inProgressPercentage") + """The percentage of in-progress cards.""" + + todo_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="todoCount") + """The number of to do cards.""" + + todo_percentage = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="todoPercentage") + """The percentage of to do cards.""" + + +class ProjectViewConnection(sgqlc.types.relay.Connection): + """The connection type for ProjectView.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ProjectViewEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ProjectView"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ProjectViewEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ProjectView", graphql_name="node") + """The item at the end of the edge.""" + + +class PublicKeyConnection(sgqlc.types.relay.Connection): + """The connection type for PublicKey.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PublicKeyEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PublicKey"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PublicKeyEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PublicKey", graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestChangedFile(sgqlc.types.Type): + """A file changed in a pull request.""" + + __schema__ = github_schema + __field_names__ = ("additions", "change_type", "deletions", "path", "viewer_viewed_state") + additions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="additions") + """The number of additions to the file.""" + + change_type = sgqlc.types.Field(sgqlc.types.non_null(PatchStatus), graphql_name="changeType") + """How the file was changed in this PullRequest""" + + deletions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="deletions") + """The number of deletions to the file.""" + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path of the file.""" + + viewer_viewed_state = sgqlc.types.Field(sgqlc.types.non_null(FileViewedState), graphql_name="viewerViewedState") + """The state of the file for the viewer.""" + + +class PullRequestChangedFileConnection(sgqlc.types.relay.Connection): + """The connection type for PullRequestChangedFile.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestChangedFileEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(PullRequestChangedFile), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PullRequestChangedFileEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(PullRequestChangedFile, graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestCommitConnection(sgqlc.types.relay.Connection): + """The connection type for PullRequestCommit.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestCommitEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PullRequestCommit"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PullRequestCommitEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PullRequestCommit", graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestConnection(sgqlc.types.relay.Connection): + """The connection type for PullRequest.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PullRequest"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PullRequestContributionsByRepository(sgqlc.types.Type): + """This aggregates pull requests opened by a user within one + repository. + """ + + __schema__ = github_schema + __field_names__ = ("contributions", "repository") + contributions = sgqlc.types.Field( + sgqlc.types.non_null(CreatedPullRequestContributionConnection), + graphql_name="contributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(ContributionOrder, graphql_name="orderBy", default={"direction": "DESC"})), + ) + ), + ) + """The pull request contributions. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`ContributionOrder`): Ordering options for + contributions returned from the connection. (default: + `{direction: DESC}`) + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository in which the pull requests were opened.""" + + +class PullRequestEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PullRequest", graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestReviewCommentConnection(sgqlc.types.relay.Connection): + """The connection type for PullRequestReviewComment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestReviewCommentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PullRequestReviewComment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PullRequestReviewCommentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PullRequestReviewComment", graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestReviewConnection(sgqlc.types.relay.Connection): + """The connection type for PullRequestReview.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestReviewEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PullRequestReview"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PullRequestReviewContributionsByRepository(sgqlc.types.Type): + """This aggregates pull request reviews made by a user within one + repository. + """ + + __schema__ = github_schema + __field_names__ = ("contributions", "repository") + contributions = sgqlc.types.Field( + sgqlc.types.non_null(CreatedPullRequestReviewContributionConnection), + graphql_name="contributions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(ContributionOrder, graphql_name="orderBy", default={"direction": "DESC"})), + ) + ), + ) + """The pull request review contributions. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`ContributionOrder`): Ordering options for + contributions returned from the connection. (default: + `{direction: DESC}`) + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository in which the pull request reviews were made.""" + + +class PullRequestReviewEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PullRequestReview", graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestReviewThreadConnection(sgqlc.types.relay.Connection): + """Review comment threads for a pull request review.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestReviewThreadEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PullRequestReviewThread"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PullRequestReviewThreadEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PullRequestReviewThread", graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestRevisionMarker(sgqlc.types.Type): + """Represents the latest point in the pull request timeline for which + the viewer has seen the pull request's commits. + """ + + __schema__ = github_schema + __field_names__ = ("created_at", "last_seen_commit", "pull_request") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + last_seen_commit = sgqlc.types.Field(sgqlc.types.non_null("Commit"), graphql_name="lastSeenCommit") + """The last commit the viewer has seen.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """The pull request to which the marker belongs.""" + + +class PullRequestTemplate(sgqlc.types.Type): + """A repository pull request template.""" + + __schema__ = github_schema + __field_names__ = ("body", "filename", "repository") + body = sgqlc.types.Field(String, graphql_name="body") + """The body of the template""" + + filename = sgqlc.types.Field(String, graphql_name="filename") + """The filename of the template""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository the template belongs to""" + + +class PullRequestTimelineConnection(sgqlc.types.relay.Connection): + """The connection type for PullRequestTimelineItem.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestTimelineItemEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PullRequestTimelineItem"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PullRequestTimelineItemEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PullRequestTimelineItem", graphql_name="node") + """The item at the end of the edge.""" + + +class PullRequestTimelineItemsConnection(sgqlc.types.relay.Connection): + """The connection type for PullRequestTimelineItems.""" + + __schema__ = github_schema + __field_names__ = ("edges", "filtered_count", "nodes", "page_count", "page_info", "total_count", "updated_at") + edges = sgqlc.types.Field(sgqlc.types.list_of("PullRequestTimelineItemsEdge"), graphql_name="edges") + """A list of edges.""" + + filtered_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="filteredCount") + """Identifies the count of items after applying `before` and `after` + filters. + """ + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PullRequestTimelineItems"), graphql_name="nodes") + """A list of nodes.""" + + page_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="pageCount") + """Identifies the count of items after applying `before`/`after` + filters and `first`/`last`/`skip` slicing. + """ + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the timeline was last updated.""" + + +class PullRequestTimelineItemsEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PullRequestTimelineItems", graphql_name="node") + """The item at the end of the edge.""" + + +class PushAllowanceConnection(sgqlc.types.relay.Connection): + """The connection type for PushAllowance.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("PushAllowanceEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("PushAllowance"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class PushAllowanceEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("PushAllowance", graphql_name="node") + """The item at the end of the edge.""" + + +class Query(sgqlc.types.Type): + """The query root of GitHub's GraphQL interface.""" + + __schema__ = github_schema + __field_names__ = ( + "code_of_conduct", + "codes_of_conduct", + "enterprise", + "enterprise_administrator_invitation", + "enterprise_administrator_invitation_by_token", + "license", + "licenses", + "marketplace_categories", + "marketplace_category", + "marketplace_listing", + "marketplace_listings", + "meta", + "node", + "nodes", + "organization", + "rate_limit", + "relay", + "repository", + "repository_owner", + "resource", + "search", + "security_advisories", + "security_advisory", + "security_vulnerabilities", + "sponsorables", + "topic", + "user", + "viewer", + ) + code_of_conduct = sgqlc.types.Field( + "CodeOfConduct", + graphql_name="codeOfConduct", + args=sgqlc.types.ArgDict((("key", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None)),)), + ) + """Look up a code of conduct by its key + + Arguments: + + * `key` (`String!`): The code of conduct's key + """ + + codes_of_conduct = sgqlc.types.Field(sgqlc.types.list_of("CodeOfConduct"), graphql_name="codesOfConduct") + """Look up a code of conduct by its key""" + + enterprise = sgqlc.types.Field( + "Enterprise", + graphql_name="enterprise", + args=sgqlc.types.ArgDict( + ( + ("slug", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="slug", default=None)), + ("invitation_token", sgqlc.types.Arg(String, graphql_name="invitationToken", default=None)), + ) + ), + ) + """Look up an enterprise by URL slug. + + Arguments: + + * `slug` (`String!`): The enterprise URL slug. + * `invitation_token` (`String`): The enterprise invitation token. + """ + + enterprise_administrator_invitation = sgqlc.types.Field( + "EnterpriseAdministratorInvitation", + graphql_name="enterpriseAdministratorInvitation", + args=sgqlc.types.ArgDict( + ( + ("user_login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="userLogin", default=None)), + ("enterprise_slug", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="enterpriseSlug", default=None)), + ("role", sgqlc.types.Arg(sgqlc.types.non_null(EnterpriseAdministratorRole), graphql_name="role", default=None)), + ) + ), + ) + """Look up a pending enterprise administrator invitation by invitee, + enterprise and role. + + Arguments: + + * `user_login` (`String!`): The login of the user invited to join + the business. + * `enterprise_slug` (`String!`): The slug of the enterprise the + user was invited to join. + * `role` (`EnterpriseAdministratorRole!`): The role for the + business member invitation. + """ + + enterprise_administrator_invitation_by_token = sgqlc.types.Field( + "EnterpriseAdministratorInvitation", + graphql_name="enterpriseAdministratorInvitationByToken", + args=sgqlc.types.ArgDict( + (("invitation_token", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="invitationToken", default=None)),) + ), + ) + """Look up a pending enterprise administrator invitation by + invitation token. + + Arguments: + + * `invitation_token` (`String!`): The invitation token sent with + the invitation email. + """ + + license = sgqlc.types.Field( + "License", + graphql_name="license", + args=sgqlc.types.ArgDict((("key", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="key", default=None)),)), + ) + """Look up an open source license by its key + + Arguments: + + * `key` (`String!`): The license's downcased SPDX ID + """ + + licenses = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of("License")), graphql_name="licenses") + """Return a list of known open source licenses""" + + marketplace_categories = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("MarketplaceCategory"))), + graphql_name="marketplaceCategories", + args=sgqlc.types.ArgDict( + ( + ( + "include_categories", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="includeCategories", default=None), + ), + ("exclude_empty", sgqlc.types.Arg(Boolean, graphql_name="excludeEmpty", default=None)), + ("exclude_subcategories", sgqlc.types.Arg(Boolean, graphql_name="excludeSubcategories", default=None)), + ) + ), + ) + """Get alphabetically sorted list of Marketplace categories + + Arguments: + + * `include_categories` (`[String!]`): Return only the specified + categories. + * `exclude_empty` (`Boolean`): Exclude categories with no + listings. + * `exclude_subcategories` (`Boolean`): Returns top level + categories only, excluding any subcategories. + """ + + marketplace_category = sgqlc.types.Field( + "MarketplaceCategory", + graphql_name="marketplaceCategory", + args=sgqlc.types.ArgDict( + ( + ("slug", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="slug", default=None)), + ("use_topic_aliases", sgqlc.types.Arg(Boolean, graphql_name="useTopicAliases", default=None)), + ) + ), + ) + """Look up a Marketplace category by its slug. + + Arguments: + + * `slug` (`String!`): The URL slug of the category. + * `use_topic_aliases` (`Boolean`): Also check topic aliases for + the category slug + """ + + marketplace_listing = sgqlc.types.Field( + "MarketplaceListing", + graphql_name="marketplaceListing", + args=sgqlc.types.ArgDict((("slug", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="slug", default=None)),)), + ) + """Look up a single Marketplace listing + + Arguments: + + * `slug` (`String!`): Select the listing that matches this slug. + It's the short name of the listing used in its URL. + """ + + marketplace_listings = sgqlc.types.Field( + sgqlc.types.non_null(MarketplaceListingConnection), + graphql_name="marketplaceListings", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("category_slug", sgqlc.types.Arg(String, graphql_name="categorySlug", default=None)), + ("use_topic_aliases", sgqlc.types.Arg(Boolean, graphql_name="useTopicAliases", default=None)), + ("viewer_can_admin", sgqlc.types.Arg(Boolean, graphql_name="viewerCanAdmin", default=None)), + ("admin_id", sgqlc.types.Arg(ID, graphql_name="adminId", default=None)), + ("organization_id", sgqlc.types.Arg(ID, graphql_name="organizationId", default=None)), + ("all_states", sgqlc.types.Arg(Boolean, graphql_name="allStates", default=None)), + ("slugs", sgqlc.types.Arg(sgqlc.types.list_of(String), graphql_name="slugs", default=None)), + ("primary_category_only", sgqlc.types.Arg(Boolean, graphql_name="primaryCategoryOnly", default=False)), + ("with_free_trials_only", sgqlc.types.Arg(Boolean, graphql_name="withFreeTrialsOnly", default=False)), + ) + ), + ) + """Look up Marketplace listings + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `category_slug` (`String`): Select only listings with the given + category. + * `use_topic_aliases` (`Boolean`): Also check topic aliases for + the category slug + * `viewer_can_admin` (`Boolean`): Select listings to which user + has admin access. If omitted, listings visible to the viewer are + returned. + * `admin_id` (`ID`): Select listings that can be administered by + the specified user. + * `organization_id` (`ID`): Select listings for products owned by + the specified organization. + * `all_states` (`Boolean`): Select listings visible to the viewer + even if they are not approved. If omitted or false, only + approved listings will be returned. + * `slugs` (`[String]`): Select the listings with these slugs, if + they are visible to the viewer. + * `primary_category_only` (`Boolean`): Select only listings where + the primary category matches the given category slug. (default: + `false`) + * `with_free_trials_only` (`Boolean`): Select only listings that + offer a free trial. (default: `false`) + """ + + meta = sgqlc.types.Field(sgqlc.types.non_null(GitHubMetadata), graphql_name="meta") + """Return information about the GitHub instance""" + + node = sgqlc.types.Field( + Node, + graphql_name="node", + args=sgqlc.types.ArgDict((("id", sgqlc.types.Arg(sgqlc.types.non_null(ID), graphql_name="id", default=None)),)), + ) + """Fetches an object given its ID. + + Arguments: + + * `id` (`ID!`): ID of the object. + """ + + nodes = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(Node)), + graphql_name="nodes", + args=sgqlc.types.ArgDict( + ( + ( + "ids", + sgqlc.types.Arg(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(ID))), graphql_name="ids", default=None), + ), + ) + ), + ) + """Lookup nodes by a list of IDs. + + Arguments: + + * `ids` (`[ID!]!`): The list of node IDs. + """ + + organization = sgqlc.types.Field( + "Organization", + graphql_name="organization", + args=sgqlc.types.ArgDict((("login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="login", default=None)),)), + ) + """Lookup a organization by login. + + Arguments: + + * `login` (`String!`): The organization's login. + """ + + rate_limit = sgqlc.types.Field( + "RateLimit", + graphql_name="rateLimit", + args=sgqlc.types.ArgDict((("dry_run", sgqlc.types.Arg(Boolean, graphql_name="dryRun", default=False)),)), + ) + """The client's rate limit information. + + Arguments: + + * `dry_run` (`Boolean`): If true, calculate the cost for the query + without evaluating it (default: `false`) + """ + + relay = sgqlc.types.Field(sgqlc.types.non_null("Query"), graphql_name="relay") + """Hack to workaround https://github.com/facebook/relay/issues/112 + re-exposing the root query object + """ + + repository = sgqlc.types.Field( + "Repository", + graphql_name="repository", + args=sgqlc.types.ArgDict( + ( + ("owner", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="owner", default=None)), + ("name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="name", default=None)), + ("follow_renames", sgqlc.types.Arg(Boolean, graphql_name="followRenames", default=True)), + ) + ), + ) + """Lookup a given repository by the owner and repository name. + + Arguments: + + * `owner` (`String!`): The login field of a user or organization + * `name` (`String!`): The name of the repository + * `follow_renames` (`Boolean`): Follow repository renames. If + disabled, a repository referenced by its old name will return an + error. (default: `true`) + """ + + repository_owner = sgqlc.types.Field( + "RepositoryOwner", + graphql_name="repositoryOwner", + args=sgqlc.types.ArgDict((("login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="login", default=None)),)), + ) + """Lookup a repository owner (ie. either a User or an Organization) + by login. + + Arguments: + + * `login` (`String!`): The username to lookup the owner by. + """ + + resource = sgqlc.types.Field( + "UniformResourceLocatable", + graphql_name="resource", + args=sgqlc.types.ArgDict((("url", sgqlc.types.Arg(sgqlc.types.non_null(URI), graphql_name="url", default=None)),)), + ) + """Lookup resource by a URL. + + Arguments: + + * `url` (`URI!`): The URL. + """ + + search = sgqlc.types.Field( + sgqlc.types.non_null("SearchResultItemConnection"), + graphql_name="search", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("query", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="query", default=None)), + ("type", sgqlc.types.Arg(sgqlc.types.non_null(SearchType), graphql_name="type", default=None)), + ) + ), + ) + """Perform a search across resources. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `query` (`String!`): The search string to look for. + * `type` (`SearchType!`): The types of search items to search + within. + """ + + security_advisories = sgqlc.types.Field( + sgqlc.types.non_null("SecurityAdvisoryConnection"), + graphql_name="securityAdvisories", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg(SecurityAdvisoryOrder, graphql_name="orderBy", default={"field": "UPDATED_AT", "direction": "DESC"}), + ), + ("identifier", sgqlc.types.Arg(SecurityAdvisoryIdentifierFilter, graphql_name="identifier", default=None)), + ("published_since", sgqlc.types.Arg(DateTime, graphql_name="publishedSince", default=None)), + ("updated_since", sgqlc.types.Arg(DateTime, graphql_name="updatedSince", default=None)), + ( + "classifications", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(SecurityAdvisoryClassification)), + graphql_name="classifications", + default=None, + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """GitHub Security Advisories + + Arguments: + + * `order_by` (`SecurityAdvisoryOrder`): Ordering options for the + returned topics. (default: `{field: UPDATED_AT, direction: + DESC}`) + * `identifier` (`SecurityAdvisoryIdentifierFilter`): Filter + advisories by identifier, e.g. GHSA or CVE. + * `published_since` (`DateTime`): Filter advisories to those + published since a time in the past. + * `updated_since` (`DateTime`): Filter advisories to those updated + since a time in the past. + * `classifications` (`[SecurityAdvisoryClassification!]`): A list + of classifications to filter advisories by. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + security_advisory = sgqlc.types.Field( + "SecurityAdvisory", + graphql_name="securityAdvisory", + args=sgqlc.types.ArgDict((("ghsa_id", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="ghsaId", default=None)),)), + ) + """Fetch a Security Advisory by its GHSA ID + + Arguments: + + * `ghsa_id` (`String!`): GitHub Security Advisory ID. + """ + + security_vulnerabilities = sgqlc.types.Field( + sgqlc.types.non_null("SecurityVulnerabilityConnection"), + graphql_name="securityVulnerabilities", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg( + SecurityVulnerabilityOrder, graphql_name="orderBy", default={"field": "UPDATED_AT", "direction": "DESC"} + ), + ), + ("ecosystem", sgqlc.types.Arg(SecurityAdvisoryEcosystem, graphql_name="ecosystem", default=None)), + ("package", sgqlc.types.Arg(String, graphql_name="package", default=None)), + ( + "severities", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(SecurityAdvisorySeverity)), graphql_name="severities", default=None + ), + ), + ( + "classifications", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(SecurityAdvisoryClassification)), + graphql_name="classifications", + default=None, + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Software Vulnerabilities documented by GitHub Security Advisories + + Arguments: + + * `order_by` (`SecurityVulnerabilityOrder`): Ordering options for + the returned topics. (default: `{field: UPDATED_AT, direction: + DESC}`) + * `ecosystem` (`SecurityAdvisoryEcosystem`): An ecosystem to + filter vulnerabilities by. + * `package` (`String`): A package name to filter vulnerabilities + by. + * `severities` (`[SecurityAdvisorySeverity!]`): A list of + severities to filter vulnerabilities by. + * `classifications` (`[SecurityAdvisoryClassification!]`): A list + of advisory classifications to filter vulnerabilities by. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + sponsorables = sgqlc.types.Field( + sgqlc.types.non_null("SponsorableItemConnection"), + graphql_name="sponsorables", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(SponsorableOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ("only_dependencies", sgqlc.types.Arg(Boolean, graphql_name="onlyDependencies", default=False)), + ("org_login_for_dependencies", sgqlc.types.Arg(String, graphql_name="orgLoginForDependencies", default=None)), + ("dependency_ecosystem", sgqlc.types.Arg(SecurityAdvisoryEcosystem, graphql_name="dependencyEcosystem", default=None)), + ("ecosystem", sgqlc.types.Arg(DependencyGraphEcosystem, graphql_name="ecosystem", default=None)), + ) + ), + ) + """Users and organizations who can be sponsored via GitHub Sponsors. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`SponsorableOrder`): Ordering options for users and + organizations returned from the connection. (default: `{field: + LOGIN, direction: ASC}`) + * `only_dependencies` (`Boolean`): Whether only sponsorables who + own the viewer's dependencies will be returned. Must be + authenticated to use. Can check an organization instead for + their dependencies owned by sponsorables by passing + orgLoginForDependencies. (default: `false`) + * `org_login_for_dependencies` (`String`): Optional organization + username for whose dependencies should be checked. Used when + onlyDependencies = true. Omit to check your own dependencies. If + you are not an administrator of the organization, only + dependencies from its public repositories will be considered. + * `dependency_ecosystem` (`SecurityAdvisoryEcosystem`): Optional + filter for which dependencies should be checked for sponsorable + owners. Only sponsorable owners of dependencies in this + ecosystem will be included. Used when onlyDependencies = true. + **Upcoming Change on 2022-07-01 UTC** **Description:** + `dependencyEcosystem` will be removed. Use the ecosystem + argument instead. **Reason:** The type is switching from + SecurityAdvisoryEcosystem to DependencyGraphEcosystem. + * `ecosystem` (`DependencyGraphEcosystem`): Optional filter for + which dependencies should be checked for sponsorable owners. + Only sponsorable owners of dependencies in this ecosystem will + be included. Used when onlyDependencies = true. + """ + + topic = sgqlc.types.Field( + "Topic", + graphql_name="topic", + args=sgqlc.types.ArgDict((("name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="name", default=None)),)), + ) + """Look up a topic by name. + + Arguments: + + * `name` (`String!`): The topic's name. + """ + + user = sgqlc.types.Field( + "User", + graphql_name="user", + args=sgqlc.types.ArgDict((("login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="login", default=None)),)), + ) + """Lookup a user by login. + + Arguments: + + * `login` (`String!`): The user's login. + """ + + viewer = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="viewer") + """The currently authenticated user.""" + + +class RateLimit(sgqlc.types.Type): + """Represents the client's rate limit.""" + + __schema__ = github_schema + __field_names__ = ("cost", "limit", "node_count", "remaining", "reset_at", "used") + cost = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="cost") + """The point cost for the current query counting against the rate + limit. + """ + + limit = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="limit") + """The maximum number of points the client is permitted to consume in + a 60 minute window. + """ + + node_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="nodeCount") + """The maximum number of nodes this query may return""" + + remaining = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="remaining") + """The number of points remaining in the current rate limit window.""" + + reset_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="resetAt") + """The time at which the current rate limit window resets in UTC + epoch seconds. + """ + + used = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="used") + """The number of points used in the current rate limit window.""" + + +class Reactable(sgqlc.types.Interface): + """Represents a subject that can be reacted on.""" + + __schema__ = github_schema + __field_names__ = ("database_id", "id", "reaction_groups", "reactions", "viewer_can_react") + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + reaction_groups = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("ReactionGroup")), graphql_name="reactionGroups") + """A list of reactions grouped by content left on the subject.""" + + reactions = sgqlc.types.Field( + sgqlc.types.non_null("ReactionConnection"), + graphql_name="reactions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("content", sgqlc.types.Arg(ReactionContent, graphql_name="content", default=None)), + ("order_by", sgqlc.types.Arg(ReactionOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """A list of Reactions left on the Issue. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `content` (`ReactionContent`): Allows filtering Reactions by + emoji. + * `order_by` (`ReactionOrder`): Allows specifying the order in + which reactions are returned. + """ + + viewer_can_react = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanReact") + """Can user react to this subject""" + + +class ReactingUserConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ReactingUserEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ReactingUserEdge(sgqlc.types.Type): + """Represents a user that's made a reaction.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "reacted_at") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="node") + + reacted_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="reactedAt") + """The moment when the user made the reaction.""" + + +class ReactionConnection(sgqlc.types.relay.Connection): + """A list of reactions that have been left on the subject.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count", "viewer_has_reacted") + edges = sgqlc.types.Field(sgqlc.types.list_of("ReactionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Reaction"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + viewer_has_reacted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerHasReacted") + """Whether or not the authenticated user has left a reaction on the + subject. + """ + + +class ReactionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Reaction", graphql_name="node") + """The item at the end of the edge.""" + + +class ReactionGroup(sgqlc.types.Type): + """A group of emoji reactions to a particular piece of content.""" + + __schema__ = github_schema + __field_names__ = ("content", "created_at", "reactors", "subject", "viewer_has_reacted") + content = sgqlc.types.Field(sgqlc.types.non_null(ReactionContent), graphql_name="content") + """Identifies the emoji reaction.""" + + created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt") + """Identifies when the reaction was created.""" + + reactors = sgqlc.types.Field( + sgqlc.types.non_null("ReactorConnection"), + graphql_name="reactors", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Reactors to the reaction subject with the emotion represented by + this reaction group. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + subject = sgqlc.types.Field(sgqlc.types.non_null(Reactable), graphql_name="subject") + """The subject that was reacted to.""" + + viewer_has_reacted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerHasReacted") + """Whether or not the authenticated user has left a reaction on the + subject. + """ + + +class ReactorConnection(sgqlc.types.relay.Connection): + """The connection type for Reactor.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ReactorEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Reactor"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ReactorEdge(sgqlc.types.Type): + """Represents an author of a reaction.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "reacted_at") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(sgqlc.types.non_null("Reactor"), graphql_name="node") + """The author of the reaction.""" + + reacted_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="reactedAt") + """The moment when the user made the reaction.""" + + +class RefConnection(sgqlc.types.relay.Connection): + """The connection type for Ref.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("RefEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Ref"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class RefEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Ref", graphql_name="node") + """The item at the end of the edge.""" + + +class RefUpdateRule(sgqlc.types.Type): + """A ref update rules for a viewer.""" + + __schema__ = github_schema + __field_names__ = ( + "allows_deletions", + "allows_force_pushes", + "blocks_creations", + "pattern", + "required_approving_review_count", + "required_status_check_contexts", + "requires_code_owner_reviews", + "requires_conversation_resolution", + "requires_linear_history", + "requires_signatures", + "viewer_allowed_to_dismiss_reviews", + "viewer_can_push", + ) + allows_deletions = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="allowsDeletions") + """Can this branch be deleted.""" + + allows_force_pushes = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="allowsForcePushes") + """Are force pushes allowed on this branch.""" + + blocks_creations = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="blocksCreations") + """Can matching branches be created.""" + + pattern = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="pattern") + """Identifies the protection rule pattern.""" + + required_approving_review_count = sgqlc.types.Field(Int, graphql_name="requiredApprovingReviewCount") + """Number of approving reviews required to update matching branches.""" + + required_status_check_contexts = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="requiredStatusCheckContexts") + """List of required status check contexts that must pass for commits + to be accepted to matching branches. + """ + + requires_code_owner_reviews = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresCodeOwnerReviews") + """Are reviews from code owners required to update matching branches.""" + + requires_conversation_resolution = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresConversationResolution") + """Are conversations required to be resolved before merging.""" + + requires_linear_history = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresLinearHistory") + """Are merge commits prohibited from being pushed to this branch.""" + + requires_signatures = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresSignatures") + """Are commits required to be signed.""" + + viewer_allowed_to_dismiss_reviews = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerAllowedToDismissReviews") + """Is the viewer allowed to dismiss reviews.""" + + viewer_can_push = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanPush") + """Can the viewer push to the branch""" + + +class RegenerateEnterpriseIdentityProviderRecoveryCodesPayload(sgqlc.types.Type): + """Autogenerated return type of + RegenerateEnterpriseIdentityProviderRecoveryCodes + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "identity_provider") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + identity_provider = sgqlc.types.Field("EnterpriseIdentityProvider", graphql_name="identityProvider") + """The identity provider for the enterprise.""" + + +class RegenerateVerifiableDomainTokenPayload(sgqlc.types.Type): + """Autogenerated return type of RegenerateVerifiableDomainToken""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "verification_token") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + verification_token = sgqlc.types.Field(String, graphql_name="verificationToken") + """The verification token that was generated.""" + + +class RejectDeploymentsPayload(sgqlc.types.Type): + """Autogenerated return type of RejectDeployments""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "deployments") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + deployments = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("Deployment")), graphql_name="deployments") + """The affected deployments.""" + + +class ReleaseAssetConnection(sgqlc.types.relay.Connection): + """The connection type for ReleaseAsset.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ReleaseAssetEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ReleaseAsset"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ReleaseAssetEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ReleaseAsset", graphql_name="node") + """The item at the end of the edge.""" + + +class ReleaseConnection(sgqlc.types.relay.Connection): + """The connection type for Release.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ReleaseEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Release"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ReleaseEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Release", graphql_name="node") + """The item at the end of the edge.""" + + +class RemoveAssigneesFromAssignablePayload(sgqlc.types.Type): + """Autogenerated return type of RemoveAssigneesFromAssignable""" + + __schema__ = github_schema + __field_names__ = ("assignable", "client_mutation_id") + assignable = sgqlc.types.Field(Assignable, graphql_name="assignable") + """The item that was unassigned.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class RemoveEnterpriseAdminPayload(sgqlc.types.Type): + """Autogenerated return type of RemoveEnterpriseAdmin""" + + __schema__ = github_schema + __field_names__ = ("admin", "client_mutation_id", "enterprise", "message", "viewer") + admin = sgqlc.types.Field("User", graphql_name="admin") + """The user who was removed as an administrator.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The updated enterprise.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of removing an administrator.""" + + viewer = sgqlc.types.Field("User", graphql_name="viewer") + """The viewer performing the mutation.""" + + +class RemoveEnterpriseIdentityProviderPayload(sgqlc.types.Type): + """Autogenerated return type of RemoveEnterpriseIdentityProvider""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "identity_provider") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + identity_provider = sgqlc.types.Field("EnterpriseIdentityProvider", graphql_name="identityProvider") + """The identity provider that was removed from the enterprise.""" + + +class RemoveEnterpriseOrganizationPayload(sgqlc.types.Type): + """Autogenerated return type of RemoveEnterpriseOrganization""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "organization", "viewer") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The updated enterprise.""" + + organization = sgqlc.types.Field("Organization", graphql_name="organization") + """The organization that was removed from the enterprise.""" + + viewer = sgqlc.types.Field("User", graphql_name="viewer") + """The viewer performing the mutation.""" + + +class RemoveEnterpriseSupportEntitlementPayload(sgqlc.types.Type): + """Autogenerated return type of RemoveEnterpriseSupportEntitlement""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of removing the support + entitlement. + """ + + +class RemoveLabelsFromLabelablePayload(sgqlc.types.Type): + """Autogenerated return type of RemoveLabelsFromLabelable""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "labelable") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + labelable = sgqlc.types.Field(Labelable, graphql_name="labelable") + """The Labelable the labels were removed from.""" + + +class RemoveOutsideCollaboratorPayload(sgqlc.types.Type): + """Autogenerated return type of RemoveOutsideCollaborator""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "removed_user") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + removed_user = sgqlc.types.Field("User", graphql_name="removedUser") + """The user that was removed as an outside collaborator.""" + + +class RemoveReactionPayload(sgqlc.types.Type): + """Autogenerated return type of RemoveReaction""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "reaction", "subject") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + reaction = sgqlc.types.Field("Reaction", graphql_name="reaction") + """The reaction object.""" + + subject = sgqlc.types.Field(Reactable, graphql_name="subject") + """The reactable subject.""" + + +class RemoveStarPayload(sgqlc.types.Type): + """Autogenerated return type of RemoveStar""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "starrable") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + starrable = sgqlc.types.Field("Starrable", graphql_name="starrable") + """The starrable.""" + + +class RemoveUpvotePayload(sgqlc.types.Type): + """Autogenerated return type of RemoveUpvote""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "subject") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + subject = sgqlc.types.Field("Votable", graphql_name="subject") + """The votable subject.""" + + +class ReopenIssuePayload(sgqlc.types.Type): + """Autogenerated return type of ReopenIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "issue") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue = sgqlc.types.Field("Issue", graphql_name="issue") + """The issue that was opened.""" + + +class ReopenPullRequestPayload(sgqlc.types.Type): + """Autogenerated return type of ReopenPullRequest""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request that was reopened.""" + + +class RepositoryAuditEntryData(sgqlc.types.Interface): + """Metadata for an audit entry with action repo.*""" + + __schema__ = github_schema + __field_names__ = ("repository", "repository_name", "repository_resource_path", "repository_url") + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository associated with the action""" + + repository_name = sgqlc.types.Field(String, graphql_name="repositoryName") + """The name of the repository""" + + repository_resource_path = sgqlc.types.Field(URI, graphql_name="repositoryResourcePath") + """The HTTP path for the repository""" + + repository_url = sgqlc.types.Field(URI, graphql_name="repositoryUrl") + """The HTTP URL for the repository""" + + +class RepositoryCodeowners(sgqlc.types.Type): + """Information extracted from a repository's `CODEOWNERS` file.""" + + __schema__ = github_schema + __field_names__ = ("errors",) + errors = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("RepositoryCodeownersError"))), graphql_name="errors" + ) + """Any problems that were encountered while parsing the `CODEOWNERS` + file. + """ + + +class RepositoryCodeownersError(sgqlc.types.Type): + """An error in a `CODEOWNERS` file.""" + + __schema__ = github_schema + __field_names__ = ("column", "kind", "line", "message", "path", "source", "suggestion") + column = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="column") + """The column number where the error occurs.""" + + kind = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="kind") + """A short string describing the type of error.""" + + line = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="line") + """The line number where the error occurs.""" + + message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message") + """A complete description of the error, combining information from + other fields. + """ + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path to the file when the error occurs.""" + + source = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="source") + """The content of the line where the error occurs.""" + + suggestion = sgqlc.types.Field(String, graphql_name="suggestion") + """A suggestion of how to fix the error.""" + + +class RepositoryCollaboratorConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("RepositoryCollaboratorEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class RepositoryCollaboratorEdge(sgqlc.types.Type): + """Represents a user who is a collaborator of a repository.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "permission", "permission_sources") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="node") + + permission = sgqlc.types.Field(sgqlc.types.non_null(RepositoryPermission), graphql_name="permission") + """The permission the user has on the repository.""" + + permission_sources = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(PermissionSource)), graphql_name="permissionSources") + """A list of sources for the user's access to the repository.""" + + +class RepositoryConnection(sgqlc.types.relay.Connection): + """A list of repositories owned by the subject.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count", "total_disk_usage") + edges = sgqlc.types.Field(sgqlc.types.list_of("RepositoryEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Repository"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + total_disk_usage = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalDiskUsage") + """The total size in kilobytes of all repositories in the connection.""" + + +class RepositoryContactLink(sgqlc.types.Type): + """A repository contact link.""" + + __schema__ = github_schema + __field_names__ = ("about", "name", "url") + about = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="about") + """The contact link purpose.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The contact link name.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The contact link URL.""" + + +class RepositoryDiscussionAuthor(sgqlc.types.Interface): + """Represents an author of discussions in repositories.""" + + __schema__ = github_schema + __field_names__ = ("repository_discussions",) + repository_discussions = sgqlc.types.Field( + sgqlc.types.non_null(DiscussionConnection), + graphql_name="repositoryDiscussions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg(DiscussionOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "DESC"}), + ), + ("repository_id", sgqlc.types.Arg(ID, graphql_name="repositoryId", default=None)), + ("answered", sgqlc.types.Arg(Boolean, graphql_name="answered", default=None)), + ) + ), + ) + """Discussions this user has started. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`DiscussionOrder`): Ordering options for discussions + returned from the connection. (default: `{field: CREATED_AT, + direction: DESC}`) + * `repository_id` (`ID`): Filter discussions to only those in a + specific repository. + * `answered` (`Boolean`): Filter discussions to only those that + have been answered or not. Defaults to including both answered + and unanswered discussions. (default: `null`) + """ + + +class RepositoryDiscussionCommentAuthor(sgqlc.types.Interface): + """Represents an author of discussion comments in repositories.""" + + __schema__ = github_schema + __field_names__ = ("repository_discussion_comments",) + repository_discussion_comments = sgqlc.types.Field( + sgqlc.types.non_null(DiscussionCommentConnection), + graphql_name="repositoryDiscussionComments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("repository_id", sgqlc.types.Arg(ID, graphql_name="repositoryId", default=None)), + ("only_answers", sgqlc.types.Arg(Boolean, graphql_name="onlyAnswers", default=False)), + ) + ), + ) + """Discussion comments this user has authored. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `repository_id` (`ID`): Filter discussion comments to only those + in a specific repository. + * `only_answers` (`Boolean`): Filter discussion comments to only + those that were marked as the answer (default: `false`) + """ + + +class RepositoryEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Repository", graphql_name="node") + """The item at the end of the edge.""" + + +class RepositoryInfo(sgqlc.types.Interface): + """A subset of repository info.""" + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "description", + "description_html", + "fork_count", + "has_issues_enabled", + "has_projects_enabled", + "has_wiki_enabled", + "homepage_url", + "is_archived", + "is_fork", + "is_in_organization", + "is_locked", + "is_mirror", + "is_private", + "is_template", + "license_info", + "lock_reason", + "mirror_url", + "name", + "name_with_owner", + "open_graph_image_url", + "owner", + "pushed_at", + "resource_path", + "short_description_html", + "updated_at", + "url", + "uses_custom_open_graph_image", + "visibility", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The description of the repository.""" + + description_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="descriptionHTML") + """The description of the repository rendered to HTML.""" + + fork_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="forkCount") + """Returns how many forks there are of this repository in the whole + network. + """ + + has_issues_enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasIssuesEnabled") + """Indicates if the repository has issues feature enabled.""" + + has_projects_enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasProjectsEnabled") + """Indicates if the repository has the Projects feature enabled.""" + + has_wiki_enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasWikiEnabled") + """Indicates if the repository has wiki feature enabled.""" + + homepage_url = sgqlc.types.Field(URI, graphql_name="homepageUrl") + """The repository's URL.""" + + is_archived = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isArchived") + """Indicates if the repository is unmaintained.""" + + is_fork = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isFork") + """Identifies if the repository is a fork.""" + + is_in_organization = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isInOrganization") + """Indicates if a repository is either owned by an organization, or + is a private fork of an organization repository. + """ + + is_locked = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isLocked") + """Indicates if the repository has been locked or not.""" + + is_mirror = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isMirror") + """Identifies if the repository is a mirror.""" + + is_private = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPrivate") + """Identifies if the repository is private or internal.""" + + is_template = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isTemplate") + """Identifies if the repository is a template that can be used to + generate new repositories. + """ + + license_info = sgqlc.types.Field("License", graphql_name="licenseInfo") + """The license associated with the repository""" + + lock_reason = sgqlc.types.Field(RepositoryLockReason, graphql_name="lockReason") + """The reason the repository has been locked.""" + + mirror_url = sgqlc.types.Field(URI, graphql_name="mirrorUrl") + """The repository's original mirror URL.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the repository.""" + + name_with_owner = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="nameWithOwner") + """The repository's name with owner.""" + + open_graph_image_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="openGraphImageUrl") + """The image used to represent this repository in Open Graph data.""" + + owner = sgqlc.types.Field(sgqlc.types.non_null("RepositoryOwner"), graphql_name="owner") + """The User owner of the repository.""" + + pushed_at = sgqlc.types.Field(DateTime, graphql_name="pushedAt") + """Identifies when the repository was last pushed to.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this repository""" + + short_description_html = sgqlc.types.Field( + sgqlc.types.non_null(HTML), + graphql_name="shortDescriptionHTML", + args=sgqlc.types.ArgDict((("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=200)),)), + ) + """A description of the repository, rendered to HTML without any + links in it. + + Arguments: + + * `limit` (`Int`): How many characters to return. (default: `200`) + """ + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this repository""" + + uses_custom_open_graph_image = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="usesCustomOpenGraphImage") + """Whether this repository has a custom image to use with Open Graph + as opposed to being represented by the owner's avatar. + """ + + visibility = sgqlc.types.Field(sgqlc.types.non_null(RepositoryVisibility), graphql_name="visibility") + """Indicates the repository's visibility level.""" + + +class RepositoryInteractionAbility(sgqlc.types.Type): + """Repository interaction limit that applies to this object.""" + + __schema__ = github_schema + __field_names__ = ("expires_at", "limit", "origin") + expires_at = sgqlc.types.Field(DateTime, graphql_name="expiresAt") + """The time the currently active limit expires.""" + + limit = sgqlc.types.Field(sgqlc.types.non_null(RepositoryInteractionLimit), graphql_name="limit") + """The current limit that is enabled on this object.""" + + origin = sgqlc.types.Field(sgqlc.types.non_null(RepositoryInteractionLimitOrigin), graphql_name="origin") + """The origin of the currently active interaction limit.""" + + +class RepositoryInvitationConnection(sgqlc.types.relay.Connection): + """A list of repository invitations.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("RepositoryInvitationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("RepositoryInvitation"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class RepositoryInvitationEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("RepositoryInvitation", graphql_name="node") + """The item at the end of the edge.""" + + +class RepositoryMigrationConnection(sgqlc.types.relay.Connection): + """The connection type for RepositoryMigration.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("RepositoryMigrationEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("RepositoryMigration"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class RepositoryMigrationEdge(sgqlc.types.Type): + """Represents a repository migration.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("RepositoryMigration", graphql_name="node") + """The item at the end of the edge.""" + + +class RepositoryNode(sgqlc.types.Interface): + """Represents a object that belongs to a repository.""" + + __schema__ = github_schema + __field_names__ = ("repository",) + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository associated with this node.""" + + +class RepositoryOwner(sgqlc.types.Interface): + """Represents an owner of a Repository.""" + + __schema__ = github_schema + __field_names__ = ("avatar_url", "id", "login", "repositories", "repository", "resource_path", "url") + avatar_url = sgqlc.types.Field( + sgqlc.types.non_null(URI), + graphql_name="avatarUrl", + args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=None)),)), + ) + """A URL pointing to the owner's public avatar. + + Arguments: + + * `size` (`Int`): The size of the resulting square image. + """ + + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The username used to login.""" + + repositories = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryConnection), + graphql_name="repositories", + args=sgqlc.types.ArgDict( + ( + ("privacy", sgqlc.types.Arg(RepositoryPrivacy, graphql_name="privacy", default=None)), + ("order_by", sgqlc.types.Arg(RepositoryOrder, graphql_name="orderBy", default=None)), + ("affiliations", sgqlc.types.Arg(sgqlc.types.list_of(RepositoryAffiliation), graphql_name="affiliations", default=None)), + ( + "owner_affiliations", + sgqlc.types.Arg( + sgqlc.types.list_of(RepositoryAffiliation), graphql_name="ownerAffiliations", default=("OWNER", "COLLABORATOR") + ), + ), + ("is_locked", sgqlc.types.Arg(Boolean, graphql_name="isLocked", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("is_fork", sgqlc.types.Arg(Boolean, graphql_name="isFork", default=None)), + ) + ), + ) + """A list of repositories that the user owns. + + Arguments: + + * `privacy` (`RepositoryPrivacy`): If non-null, filters + repositories according to privacy + * `order_by` (`RepositoryOrder`): Ordering options for + repositories returned from the connection + * `affiliations` (`[RepositoryAffiliation]`): Array of viewer's + affiliation options for repositories returned from the + connection. For example, OWNER will include only repositories + that the current viewer owns. + * `owner_affiliations` (`[RepositoryAffiliation]`): Array of + owner's affiliation options for repositories returned from the + connection. For example, OWNER will include only repositories + that the organization or user being viewed owns. (default: + `[OWNER, COLLABORATOR]`) + * `is_locked` (`Boolean`): If non-null, filters repositories + according to whether they have been locked + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `is_fork` (`Boolean`): If non-null, filters repositories + according to whether they are forks of another repository + """ + + repository = sgqlc.types.Field( + "Repository", + graphql_name="repository", + args=sgqlc.types.ArgDict( + ( + ("name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="name", default=None)), + ("follow_renames", sgqlc.types.Arg(Boolean, graphql_name="followRenames", default=True)), + ) + ), + ) + """Find Repository. + + Arguments: + + * `name` (`String!`): Name of Repository to find. + * `follow_renames` (`Boolean`): Follow repository renames. If + disabled, a repository referenced by its old name will return an + error. (default: `true`) + """ + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP URL for the owner.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for the owner.""" + + +class RepositoryTopicConnection(sgqlc.types.relay.Connection): + """The connection type for RepositoryTopic.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("RepositoryTopicEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("RepositoryTopic"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class RepositoryTopicEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("RepositoryTopic", graphql_name="node") + """The item at the end of the edge.""" + + +class RepositoryVulnerabilityAlertConnection(sgqlc.types.relay.Connection): + """The connection type for RepositoryVulnerabilityAlert.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("RepositoryVulnerabilityAlertEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("RepositoryVulnerabilityAlert"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class RepositoryVulnerabilityAlertEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("RepositoryVulnerabilityAlert", graphql_name="node") + """The item at the end of the edge.""" + + +class RequestReviewsPayload(sgqlc.types.Type): + """Autogenerated return type of RequestReviews""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "pull_request", "requested_reviewers_edge") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The pull request that is getting requests.""" + + requested_reviewers_edge = sgqlc.types.Field("UserEdge", graphql_name="requestedReviewersEdge") + """The edge from the pull request to the requested reviewers.""" + + +class RequirableByPullRequest(sgqlc.types.Interface): + """Represents a type that can be required by a pull request for + merging. + """ + + __schema__ = github_schema + __field_names__ = ("is_required",) + is_required = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), + graphql_name="isRequired", + args=sgqlc.types.ArgDict( + ( + ("pull_request_id", sgqlc.types.Arg(ID, graphql_name="pullRequestId", default=None)), + ("pull_request_number", sgqlc.types.Arg(Int, graphql_name="pullRequestNumber", default=None)), + ) + ), + ) + """Whether this is required to pass before merging for a specific + pull request. + + Arguments: + + * `pull_request_id` (`ID`): The id of the pull request this is + required for + * `pull_request_number` (`Int`): The number of the pull request + this is required for + """ + + +class RequiredStatusCheckDescription(sgqlc.types.Type): + """Represents a required status check for a protected branch, but not + any specific run of that check. + """ + + __schema__ = github_schema + __field_names__ = ("app", "context") + app = sgqlc.types.Field("App", graphql_name="app") + """The App that must provide this status in order for it to be + accepted. + """ + + context = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="context") + """The name of this status.""" + + +class RerequestCheckSuitePayload(sgqlc.types.Type): + """Autogenerated return type of RerequestCheckSuite""" + + __schema__ = github_schema + __field_names__ = ("check_suite", "client_mutation_id") + check_suite = sgqlc.types.Field("CheckSuite", graphql_name="checkSuite") + """The requested check suite.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class ResolveReviewThreadPayload(sgqlc.types.Type): + """Autogenerated return type of ResolveReviewThread""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "thread") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + thread = sgqlc.types.Field("PullRequestReviewThread", graphql_name="thread") + """The thread to resolve.""" + + +class ReviewDismissalAllowanceConnection(sgqlc.types.relay.Connection): + """The connection type for ReviewDismissalAllowance.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ReviewDismissalAllowanceEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ReviewDismissalAllowance"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ReviewDismissalAllowanceEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ReviewDismissalAllowance", graphql_name="node") + """The item at the end of the edge.""" + + +class ReviewRequestConnection(sgqlc.types.relay.Connection): + """The connection type for ReviewRequest.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("ReviewRequestEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("ReviewRequest"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class ReviewRequestEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("ReviewRequest", graphql_name="node") + """The item at the end of the edge.""" + + +class RevokeEnterpriseOrganizationsMigratorRolePayload(sgqlc.types.Type): + """Autogenerated return type of + RevokeEnterpriseOrganizationsMigratorRole + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "organizations") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + organizations = sgqlc.types.Field( + OrganizationConnection, + graphql_name="organizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The organizations that had the migrator role revoked for the given + user. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class RevokeMigratorRolePayload(sgqlc.types.Type): + """Autogenerated return type of RevokeMigratorRole""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "success") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + success = sgqlc.types.Field(Boolean, graphql_name="success") + """Did the operation succeed?""" + + +class SavedReplyConnection(sgqlc.types.relay.Connection): + """The connection type for SavedReply.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SavedReplyEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("SavedReply"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SavedReplyEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("SavedReply", graphql_name="node") + """The item at the end of the edge.""" + + +class SearchResultItemConnection(sgqlc.types.relay.Connection): + """A list of results that matched against a search query.""" + + __schema__ = github_schema + __field_names__ = ( + "code_count", + "discussion_count", + "edges", + "issue_count", + "nodes", + "page_info", + "repository_count", + "user_count", + "wiki_count", + ) + code_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="codeCount") + """The number of pieces of code that matched the search query.""" + + discussion_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="discussionCount") + """The number of discussions that matched the search query.""" + + edges = sgqlc.types.Field(sgqlc.types.list_of("SearchResultItemEdge"), graphql_name="edges") + """A list of edges.""" + + issue_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="issueCount") + """The number of issues that matched the search query.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("SearchResultItem"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + repository_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="repositoryCount") + """The number of repositories that matched the search query.""" + + user_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="userCount") + """The number of users that matched the search query.""" + + wiki_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="wikiCount") + """The number of wiki pages that matched the search query.""" + + +class SearchResultItemEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "text_matches") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("SearchResultItem", graphql_name="node") + """The item at the end of the edge.""" + + text_matches = sgqlc.types.Field(sgqlc.types.list_of("TextMatch"), graphql_name="textMatches") + """Text matches on the result found.""" + + +class SecurityAdvisoryConnection(sgqlc.types.relay.Connection): + """The connection type for SecurityAdvisory.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SecurityAdvisoryEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("SecurityAdvisory"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SecurityAdvisoryEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("SecurityAdvisory", graphql_name="node") + """The item at the end of the edge.""" + + +class SecurityAdvisoryIdentifier(sgqlc.types.Type): + """A GitHub Security Advisory Identifier""" + + __schema__ = github_schema + __field_names__ = ("type", "value") + type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type") + """The identifier type, e.g. GHSA, CVE""" + + value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value") + """The identifier""" + + +class SecurityAdvisoryPackage(sgqlc.types.Type): + """An individual package""" + + __schema__ = github_schema + __field_names__ = ("ecosystem", "name") + ecosystem = sgqlc.types.Field(sgqlc.types.non_null(SecurityAdvisoryEcosystem), graphql_name="ecosystem") + """The ecosystem the package belongs to, e.g. RUBYGEMS, NPM""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The package name""" + + +class SecurityAdvisoryPackageVersion(sgqlc.types.Type): + """An individual package version""" + + __schema__ = github_schema + __field_names__ = ("identifier",) + identifier = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="identifier") + """The package name or version""" + + +class SecurityAdvisoryReference(sgqlc.types.Type): + """A GitHub Security Advisory Reference""" + + __schema__ = github_schema + __field_names__ = ("url",) + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """A publicly accessible reference""" + + +class SecurityVulnerability(sgqlc.types.Type): + """An individual vulnerability within an Advisory""" + + __schema__ = github_schema + __field_names__ = ("advisory", "first_patched_version", "package", "severity", "updated_at", "vulnerable_version_range") + advisory = sgqlc.types.Field(sgqlc.types.non_null("SecurityAdvisory"), graphql_name="advisory") + """The Advisory associated with this Vulnerability""" + + first_patched_version = sgqlc.types.Field(SecurityAdvisoryPackageVersion, graphql_name="firstPatchedVersion") + """The first version containing a fix for the vulnerability""" + + package = sgqlc.types.Field(sgqlc.types.non_null(SecurityAdvisoryPackage), graphql_name="package") + """A description of the vulnerable package""" + + severity = sgqlc.types.Field(sgqlc.types.non_null(SecurityAdvisorySeverity), graphql_name="severity") + """The severity of the vulnerability within this package""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """When the vulnerability was last updated""" + + vulnerable_version_range = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="vulnerableVersionRange") + """A string that describes the vulnerable package versions. This + string follows a basic syntax with a few forms. + `= 0.2.0` + denotes a single vulnerable version. + `<= 1.0.8` denotes a + version range up to and including the specified version + `< + 0.1.11` denotes a version range up to, but excluding, the + specified version + `>= 4.3.0, < 4.3.5` denotes a version range + with a known minimum and maximum version. + `>= 0.0.1` denotes a + version range with a known minimum, but no known maximum + """ + + +class SecurityVulnerabilityConnection(sgqlc.types.relay.Connection): + """The connection type for SecurityVulnerability.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SecurityVulnerabilityEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(SecurityVulnerability), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SecurityVulnerabilityEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(SecurityVulnerability, graphql_name="node") + """The item at the end of the edge.""" + + +class SetEnterpriseIdentityProviderPayload(sgqlc.types.Type): + """Autogenerated return type of SetEnterpriseIdentityProvider""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "identity_provider") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + identity_provider = sgqlc.types.Field("EnterpriseIdentityProvider", graphql_name="identityProvider") + """The identity provider for the enterprise.""" + + +class SetOrganizationInteractionLimitPayload(sgqlc.types.Type): + """Autogenerated return type of SetOrganizationInteractionLimit""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "organization") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + organization = sgqlc.types.Field("Organization", graphql_name="organization") + """The organization that the interaction limit was set for.""" + + +class SetRepositoryInteractionLimitPayload(sgqlc.types.Type): + """Autogenerated return type of SetRepositoryInteractionLimit""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository that the interaction limit was set for.""" + + +class SetUserInteractionLimitPayload(sgqlc.types.Type): + """Autogenerated return type of SetUserInteractionLimit""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "user") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + user = sgqlc.types.Field("User", graphql_name="user") + """The user that the interaction limit was set for.""" + + +class SortBy(sgqlc.types.Type): + """Represents a sort by field and direction.""" + + __schema__ = github_schema + __field_names__ = ("direction", "field") + direction = sgqlc.types.Field(sgqlc.types.non_null(OrderDirection), graphql_name="direction") + """The direction of the sorting. Possible values are ASC and DESC.""" + + field = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="field") + """The id of the field by which the column is sorted.""" + + +class SponsorConnection(sgqlc.types.relay.Connection): + """The connection type for Sponsor.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SponsorEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Sponsor"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SponsorEdge(sgqlc.types.Type): + """Represents a user or organization who is sponsoring someone in + GitHub Sponsors. + """ + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Sponsor", graphql_name="node") + """The item at the end of the edge.""" + + +class Sponsorable(sgqlc.types.Interface): + """Entities that can be sponsored through GitHub Sponsors""" + + __schema__ = github_schema + __field_names__ = ( + "estimated_next_sponsors_payout_in_cents", + "has_sponsors_listing", + "is_sponsored_by", + "is_sponsoring_viewer", + "monthly_estimated_sponsors_income_in_cents", + "sponsoring", + "sponsors", + "sponsors_activities", + "sponsors_listing", + "sponsorship_for_viewer_as_sponsor", + "sponsorship_for_viewer_as_sponsorable", + "sponsorship_newsletters", + "sponsorships_as_maintainer", + "sponsorships_as_sponsor", + "viewer_can_sponsor", + "viewer_is_sponsoring", + ) + estimated_next_sponsors_payout_in_cents = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="estimatedNextSponsorsPayoutInCents" + ) + """The estimated next GitHub Sponsors payout for this + user/organization in cents (USD). + """ + + has_sponsors_listing = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasSponsorsListing") + """True if this user/organization has a GitHub Sponsors listing.""" + + is_sponsored_by = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), + graphql_name="isSponsoredBy", + args=sgqlc.types.ArgDict( + (("account_login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="accountLogin", default=None)),) + ), + ) + """Check if the given account is sponsoring this user/organization. + + Arguments: + + * `account_login` (`String!`): The target account's login. + """ + + is_sponsoring_viewer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSponsoringViewer") + """True if the viewer is sponsored by this user/organization.""" + + monthly_estimated_sponsors_income_in_cents = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="monthlyEstimatedSponsorsIncomeInCents" + ) + """The estimated monthly GitHub Sponsors income for this + user/organization in cents (USD). + """ + + sponsoring = sgqlc.types.Field( + sgqlc.types.non_null(SponsorConnection), + graphql_name="sponsoring", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(SponsorOrder, graphql_name="orderBy", default={"field": "RELEVANCE", "direction": "DESC"})), + ) + ), + ) + """List of users and organizations this entity is sponsoring. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`SponsorOrder`): Ordering options for the users and + organizations returned from the connection. (default: `{field: + RELEVANCE, direction: DESC}`) + """ + + sponsors = sgqlc.types.Field( + sgqlc.types.non_null(SponsorConnection), + graphql_name="sponsors", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("tier_id", sgqlc.types.Arg(ID, graphql_name="tierId", default=None)), + ("order_by", sgqlc.types.Arg(SponsorOrder, graphql_name="orderBy", default={"field": "RELEVANCE", "direction": "DESC"})), + ) + ), + ) + """List of sponsors for this user or organization. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `tier_id` (`ID`): If given, will filter for sponsors at the + given tier. Will only return sponsors whose tier the viewer is + permitted to see. + * `order_by` (`SponsorOrder`): Ordering options for sponsors + returned from the connection. (default: `{field: RELEVANCE, + direction: DESC}`) + """ + + sponsors_activities = sgqlc.types.Field( + sgqlc.types.non_null("SponsorsActivityConnection"), + graphql_name="sponsorsActivities", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("period", sgqlc.types.Arg(SponsorsActivityPeriod, graphql_name="period", default="MONTH")), + ( + "order_by", + sgqlc.types.Arg(SponsorsActivityOrder, graphql_name="orderBy", default={"field": "TIMESTAMP", "direction": "DESC"}), + ), + ) + ), + ) + """Events involving this sponsorable, such as new sponsorships. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `period` (`SponsorsActivityPeriod`): Filter activities returned + to only those that occurred in a given time range. (default: + `MONTH`) + * `order_by` (`SponsorsActivityOrder`): Ordering options for + activity returned from the connection. (default: `{field: + TIMESTAMP, direction: DESC}`) + """ + + sponsors_listing = sgqlc.types.Field("SponsorsListing", graphql_name="sponsorsListing") + """The GitHub Sponsors listing for this user or organization.""" + + sponsorship_for_viewer_as_sponsor = sgqlc.types.Field("Sponsorship", graphql_name="sponsorshipForViewerAsSponsor") + """The sponsorship from the viewer to this user/organization; that + is, the sponsorship where you're the sponsor. Only returns a + sponsorship if it is active. + """ + + sponsorship_for_viewer_as_sponsorable = sgqlc.types.Field("Sponsorship", graphql_name="sponsorshipForViewerAsSponsorable") + """The sponsorship from this user/organization to the viewer; that + is, the sponsorship you're receiving. Only returns a sponsorship + if it is active. + """ + + sponsorship_newsletters = sgqlc.types.Field( + sgqlc.types.non_null("SponsorshipNewsletterConnection"), + graphql_name="sponsorshipNewsletters", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SponsorshipNewsletterOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "DESC"} + ), + ), + ) + ), + ) + """List of sponsorship updates sent from this sponsorable to + sponsors. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`SponsorshipNewsletterOrder`): Ordering options for + sponsorship updates returned from the connection. (default: + `{field: CREATED_AT, direction: DESC}`) + """ + + sponsorships_as_maintainer = sgqlc.types.Field( + sgqlc.types.non_null("SponsorshipConnection"), + graphql_name="sponsorshipsAsMaintainer", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("include_private", sgqlc.types.Arg(Boolean, graphql_name="includePrivate", default=False)), + ("order_by", sgqlc.types.Arg(SponsorshipOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """This object's sponsorships as the maintainer. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `include_private` (`Boolean`): Whether or not to include private + sponsorships in the result set (default: `false`) + * `order_by` (`SponsorshipOrder`): Ordering options for + sponsorships returned from this connection. If left blank, the + sponsorships will be ordered based on relevancy to the viewer. + """ + + sponsorships_as_sponsor = sgqlc.types.Field( + sgqlc.types.non_null("SponsorshipConnection"), + graphql_name="sponsorshipsAsSponsor", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(SponsorshipOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """This object's sponsorships as the sponsor. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`SponsorshipOrder`): Ordering options for + sponsorships returned from this connection. If left blank, the + sponsorships will be ordered based on relevancy to the viewer. + """ + + viewer_can_sponsor = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanSponsor") + """Whether or not the viewer is able to sponsor this + user/organization. + """ + + viewer_is_sponsoring = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerIsSponsoring") + """True if the viewer is sponsoring this user/organization.""" + + +class SponsorableItemConnection(sgqlc.types.relay.Connection): + """The connection type for SponsorableItem.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SponsorableItemEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("SponsorableItem"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SponsorableItemEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("SponsorableItem", graphql_name="node") + """The item at the end of the edge.""" + + +class SponsorsActivityConnection(sgqlc.types.relay.Connection): + """The connection type for SponsorsActivity.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SponsorsActivityEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("SponsorsActivity"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SponsorsActivityEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("SponsorsActivity", graphql_name="node") + """The item at the end of the edge.""" + + +class SponsorsGoal(sgqlc.types.Type): + """A goal associated with a GitHub Sponsors listing, representing a + target the sponsored maintainer would like to attain. + """ + + __schema__ = github_schema + __field_names__ = ("description", "kind", "percent_complete", "target_value", "title") + description = sgqlc.types.Field(String, graphql_name="description") + """A description of the goal from the maintainer.""" + + kind = sgqlc.types.Field(sgqlc.types.non_null(SponsorsGoalKind), graphql_name="kind") + """What the objective of this goal is.""" + + percent_complete = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="percentComplete") + """The percentage representing how complete this goal is, between + 0-100. + """ + + target_value = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="targetValue") + """What the goal amount is. Represents an amount in USD for monthly + sponsorship amount goals. Represents a count of unique sponsors + for total sponsors count goals. + """ + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """A brief summary of the kind and target value of this goal.""" + + +class SponsorsTierAdminInfo(sgqlc.types.Type): + """SponsorsTier information only visible to users that can administer + the associated Sponsors listing. + """ + + __schema__ = github_schema + __field_names__ = ("sponsorships",) + sponsorships = sgqlc.types.Field( + sgqlc.types.non_null("SponsorshipConnection"), + graphql_name="sponsorships", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("include_private", sgqlc.types.Arg(Boolean, graphql_name="includePrivate", default=False)), + ("order_by", sgqlc.types.Arg(SponsorshipOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """The sponsorships associated with this tier. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `include_private` (`Boolean`): Whether or not to include private + sponsorships in the result set (default: `false`) + * `order_by` (`SponsorshipOrder`): Ordering options for + sponsorships returned from this connection. If left blank, the + sponsorships will be ordered based on relevancy to the viewer. + """ + + +class SponsorsTierConnection(sgqlc.types.relay.Connection): + """The connection type for SponsorsTier.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SponsorsTierEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("SponsorsTier"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SponsorsTierEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("SponsorsTier", graphql_name="node") + """The item at the end of the edge.""" + + +class SponsorshipConnection(sgqlc.types.relay.Connection): + """The connection type for Sponsorship.""" + + __schema__ = github_schema + __field_names__ = ( + "edges", + "nodes", + "page_info", + "total_count", + "total_recurring_monthly_price_in_cents", + "total_recurring_monthly_price_in_dollars", + ) + edges = sgqlc.types.Field(sgqlc.types.list_of("SponsorshipEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Sponsorship"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + total_recurring_monthly_price_in_cents = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalRecurringMonthlyPriceInCents") + """The total amount in cents of all recurring sponsorships in the + connection whose amount you can view. Does not include one-time + sponsorships. + """ + + total_recurring_monthly_price_in_dollars = sgqlc.types.Field( + sgqlc.types.non_null(Int), graphql_name="totalRecurringMonthlyPriceInDollars" + ) + """The total amount in USD of all recurring sponsorships in the + connection whose amount you can view. Does not include one-time + sponsorships. + """ + + +class SponsorshipEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Sponsorship", graphql_name="node") + """The item at the end of the edge.""" + + +class SponsorshipNewsletterConnection(sgqlc.types.relay.Connection): + """The connection type for SponsorshipNewsletter.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SponsorshipNewsletterEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("SponsorshipNewsletter"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SponsorshipNewsletterEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("SponsorshipNewsletter", graphql_name="node") + """The item at the end of the edge.""" + + +class StargazerConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("StargazerEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class StargazerEdge(sgqlc.types.Type): + """Represents a user that's starred a repository.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "starred_at") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="node") + + starred_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="starredAt") + """Identifies when the item was starred.""" + + +class Starrable(sgqlc.types.Interface): + """Things that can be starred.""" + + __schema__ = github_schema + __field_names__ = ("id", "stargazer_count", "stargazers", "viewer_has_starred") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + stargazer_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="stargazerCount") + """Returns a count of how many stargazers there are on this object""" + + stargazers = sgqlc.types.Field( + sgqlc.types.non_null(StargazerConnection), + graphql_name="stargazers", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(StarOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """A list of users who have starred this starrable. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`StarOrder`): Order for connection + """ + + viewer_has_starred = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerHasStarred") + """Returns a boolean indicating whether the viewing user has starred + this starrable. + """ + + +class StarredRepositoryConnection(sgqlc.types.relay.Connection): + """The connection type for Repository.""" + + __schema__ = github_schema + __field_names__ = ("edges", "is_over_limit", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("StarredRepositoryEdge"), graphql_name="edges") + """A list of edges.""" + + is_over_limit = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isOverLimit") + """Is the list of stars for this user truncated? This is true for + users that have many stars. + """ + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Repository"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class StarredRepositoryEdge(sgqlc.types.Type): + """Represents a starred repository.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "starred_at") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="node") + + starred_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="starredAt") + """Identifies when the item was starred.""" + + +class StartRepositoryMigrationPayload(sgqlc.types.Type): + """Autogenerated return type of StartRepositoryMigration""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository_migration") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository_migration = sgqlc.types.Field("RepositoryMigration", graphql_name="repositoryMigration") + """The new Octoshift repository migration.""" + + +class StatusCheckRollupContextConnection(sgqlc.types.relay.Connection): + """The connection type for StatusCheckRollupContext.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("StatusCheckRollupContextEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("StatusCheckRollupContext"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class StatusCheckRollupContextEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("StatusCheckRollupContext", graphql_name="node") + """The item at the end of the edge.""" + + +class SubmitPullRequestReviewPayload(sgqlc.types.Type): + """Autogenerated return type of SubmitPullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request_review") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request_review = sgqlc.types.Field("PullRequestReview", graphql_name="pullRequestReview") + """The submitted pull request review.""" + + +class Submodule(sgqlc.types.Type): + """A pointer to a repository at a specific revision embedded inside + another repository. + """ + + __schema__ = github_schema + __field_names__ = ("branch", "git_url", "name", "path", "subproject_commit_oid") + branch = sgqlc.types.Field(String, graphql_name="branch") + """The branch of the upstream submodule for tracking updates""" + + git_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="gitUrl") + """The git URL of the submodule repository""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the submodule in .gitmodules""" + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path in the superproject that this submodule is located in""" + + subproject_commit_oid = sgqlc.types.Field(GitObjectID, graphql_name="subprojectCommitOid") + """The commit revision of the subproject repository being tracked by + the submodule + """ + + +class SubmoduleConnection(sgqlc.types.relay.Connection): + """The connection type for Submodule.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("SubmoduleEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of(Submodule), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class SubmoduleEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(Submodule, graphql_name="node") + """The item at the end of the edge.""" + + +class Subscribable(sgqlc.types.Interface): + """Entities that can be subscribed to for web and email + notifications. + """ + + __schema__ = github_schema + __field_names__ = ("id", "viewer_can_subscribe", "viewer_subscription") + id = sgqlc.types.Field(sgqlc.types.non_null(ID), graphql_name="id") + + viewer_can_subscribe = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanSubscribe") + """Check if the viewer is able to change their subscription status + for the repository. + """ + + viewer_subscription = sgqlc.types.Field(SubscriptionState, graphql_name="viewerSubscription") + """Identifies if the viewer is watching, not watching, or ignoring + the subscribable entity. + """ + + +class SuggestedReviewer(sgqlc.types.Type): + """A suggestion to review a pull request based on a user's commit + history and review comments. + """ + + __schema__ = github_schema + __field_names__ = ("is_author", "is_commenter", "reviewer") + is_author = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isAuthor") + """Is this suggestion based on past commits?""" + + is_commenter = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCommenter") + """Is this suggestion based on past review comments?""" + + reviewer = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="reviewer") + """Identifies the user suggested to review the pull request.""" + + +class TeamAuditEntryData(sgqlc.types.Interface): + """Metadata for an audit entry with action team.*""" + + __schema__ = github_schema + __field_names__ = ("team", "team_name", "team_resource_path", "team_url") + team = sgqlc.types.Field("Team", graphql_name="team") + """The team associated with the action""" + + team_name = sgqlc.types.Field(String, graphql_name="teamName") + """The name of the team""" + + team_resource_path = sgqlc.types.Field(URI, graphql_name="teamResourcePath") + """The HTTP path for this team""" + + team_url = sgqlc.types.Field(URI, graphql_name="teamUrl") + """The HTTP URL for this team""" + + +class TeamConnection(sgqlc.types.relay.Connection): + """The connection type for Team.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("TeamEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Team"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class TeamDiscussionCommentConnection(sgqlc.types.relay.Connection): + """The connection type for TeamDiscussionComment.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("TeamDiscussionCommentEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("TeamDiscussionComment"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class TeamDiscussionCommentEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("TeamDiscussionComment", graphql_name="node") + """The item at the end of the edge.""" + + +class TeamDiscussionConnection(sgqlc.types.relay.Connection): + """The connection type for TeamDiscussion.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("TeamDiscussionEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("TeamDiscussion"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class TeamDiscussionEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("TeamDiscussion", graphql_name="node") + """The item at the end of the edge.""" + + +class TeamEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("Team", graphql_name="node") + """The item at the end of the edge.""" + + +class TeamMemberConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("TeamMemberEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class TeamMemberEdge(sgqlc.types.Type): + """Represents a user who is a member of a team.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "member_access_resource_path", "member_access_url", "node", "role") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + member_access_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="memberAccessResourcePath") + """The HTTP path to the organization's member access page.""" + + member_access_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="memberAccessUrl") + """The HTTP URL to the organization's member access page.""" + + node = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="node") + + role = sgqlc.types.Field(sgqlc.types.non_null(TeamMemberRole), graphql_name="role") + """The role the member has on the team.""" + + +class TeamRepositoryConnection(sgqlc.types.relay.Connection): + """The connection type for Repository.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("TeamRepositoryEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("Repository"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class TeamRepositoryEdge(sgqlc.types.Type): + """Represents a team repository.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node", "permission") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="node") + + permission = sgqlc.types.Field(sgqlc.types.non_null(RepositoryPermission), graphql_name="permission") + """The permission level the team has on the repository""" + + +class TextMatch(sgqlc.types.Type): + """A text match within a search result.""" + + __schema__ = github_schema + __field_names__ = ("fragment", "highlights", "property") + fragment = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fragment") + """The specific text fragment within the property matched on.""" + + highlights = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("TextMatchHighlight"))), graphql_name="highlights" + ) + """Highlights within the matched fragment.""" + + property = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="property") + """The property matched on.""" + + +class TextMatchHighlight(sgqlc.types.Type): + """Represents a single highlight in a search result match.""" + + __schema__ = github_schema + __field_names__ = ("begin_indice", "end_indice", "text") + begin_indice = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="beginIndice") + """The indice in the fragment where the matched text begins.""" + + end_indice = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="endIndice") + """The indice in the fragment where the matched text ends.""" + + text = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="text") + """The text matched.""" + + +class TopicAuditEntryData(sgqlc.types.Interface): + """Metadata for an audit entry with a topic.""" + + __schema__ = github_schema + __field_names__ = ("topic", "topic_name") + topic = sgqlc.types.Field("Topic", graphql_name="topic") + """The name of the topic added to the repository""" + + topic_name = sgqlc.types.Field(String, graphql_name="topicName") + """The name of the topic added to the repository""" + + +class TransferIssuePayload(sgqlc.types.Type): + """Autogenerated return type of TransferIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "issue") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue = sgqlc.types.Field("Issue", graphql_name="issue") + """The issue that was transferred""" + + +class TreeEntry(sgqlc.types.Type): + """Represents a Git tree entry.""" + + __schema__ = github_schema + __field_names__ = ( + "extension", + "is_generated", + "line_count", + "mode", + "name", + "object", + "oid", + "path", + "repository", + "submodule", + "type", + ) + extension = sgqlc.types.Field(String, graphql_name="extension") + """The extension of the file""" + + is_generated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isGenerated") + """Whether or not this tree entry is generated""" + + line_count = sgqlc.types.Field(Int, graphql_name="lineCount") + """Number of lines in the file.""" + + mode = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="mode") + """Entry file mode.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Entry file name.""" + + object = sgqlc.types.Field(GitObject, graphql_name="object") + """Entry file object.""" + + oid = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="oid") + """Entry file Git object ID.""" + + path = sgqlc.types.Field(String, graphql_name="path") + """The full path of the file.""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The Repository the tree entry belongs to""" + + submodule = sgqlc.types.Field(Submodule, graphql_name="submodule") + """If the TreeEntry is for a directory occupied by a submodule + project, this returns the corresponding submodule + """ + + type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="type") + """Entry file type.""" + + +class UnarchiveRepositoryPayload(sgqlc.types.Type): + """Autogenerated return type of UnarchiveRepository""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository that was unarchived.""" + + +class UnfollowOrganizationPayload(sgqlc.types.Type): + """Autogenerated return type of UnfollowOrganization""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "organization") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + organization = sgqlc.types.Field("Organization", graphql_name="organization") + """The organization that was unfollowed.""" + + +class UnfollowUserPayload(sgqlc.types.Type): + """Autogenerated return type of UnfollowUser""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "user") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + user = sgqlc.types.Field("User", graphql_name="user") + """The user that was unfollowed.""" + + +class UniformResourceLocatable(sgqlc.types.Interface): + """Represents a type that can be retrieved by a URL.""" + + __schema__ = github_schema + __field_names__ = ("resource_path", "url") + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTML path to this resource.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The URL to this resource.""" + + +class UnlinkRepositoryFromProjectPayload(sgqlc.types.Type): + """Autogenerated return type of UnlinkRepositoryFromProject""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project = sgqlc.types.Field("Project", graphql_name="project") + """The linked Project.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The linked Repository.""" + + +class UnlockLockablePayload(sgqlc.types.Type): + """Autogenerated return type of UnlockLockable""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "unlocked_record") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + unlocked_record = sgqlc.types.Field(Lockable, graphql_name="unlockedRecord") + """The item that was unlocked.""" + + +class UnmarkDiscussionCommentAsAnswerPayload(sgqlc.types.Type): + """Autogenerated return type of UnmarkDiscussionCommentAsAnswer""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "discussion") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + discussion = sgqlc.types.Field("Discussion", graphql_name="discussion") + """The discussion that includes the comment.""" + + +class UnmarkFileAsViewedPayload(sgqlc.types.Type): + """Autogenerated return type of UnmarkFileAsViewed""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The updated pull request.""" + + +class UnmarkIssueAsDuplicatePayload(sgqlc.types.Type): + """Autogenerated return type of UnmarkIssueAsDuplicate""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "duplicate") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + duplicate = sgqlc.types.Field("IssueOrPullRequest", graphql_name="duplicate") + """The issue or pull request that was marked as a duplicate.""" + + +class UnminimizeCommentPayload(sgqlc.types.Type): + """Autogenerated return type of UnminimizeComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "unminimized_comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + unminimized_comment = sgqlc.types.Field(Minimizable, graphql_name="unminimizedComment") + """The comment that was unminimized.""" + + +class UnpinIssuePayload(sgqlc.types.Type): + """Autogenerated return type of UnpinIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "issue") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue = sgqlc.types.Field("Issue", graphql_name="issue") + """The issue that was unpinned""" + + +class UnresolveReviewThreadPayload(sgqlc.types.Type): + """Autogenerated return type of UnresolveReviewThread""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "thread") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + thread = sgqlc.types.Field("PullRequestReviewThread", graphql_name="thread") + """The thread to resolve.""" + + +class Updatable(sgqlc.types.Interface): + """Entities that can be updated.""" + + __schema__ = github_schema + __field_names__ = ("viewer_can_update",) + viewer_can_update = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanUpdate") + """Check if the current viewer can update this object.""" + + +class UpdatableComment(sgqlc.types.Interface): + """Comments that can be updated.""" + + __schema__ = github_schema + __field_names__ = ("viewer_cannot_update_reasons",) + viewer_cannot_update_reasons = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(CommentCannotUpdateReason))), graphql_name="viewerCannotUpdateReasons" + ) + """Reasons why the current viewer can not update this comment.""" + + +class UpdateBranchProtectionRulePayload(sgqlc.types.Type): + """Autogenerated return type of UpdateBranchProtectionRule""" + + __schema__ = github_schema + __field_names__ = ("branch_protection_rule", "client_mutation_id") + branch_protection_rule = sgqlc.types.Field("BranchProtectionRule", graphql_name="branchProtectionRule") + """The newly created BranchProtectionRule.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateCheckRunPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateCheckRun""" + + __schema__ = github_schema + __field_names__ = ("check_run", "client_mutation_id") + check_run = sgqlc.types.Field("CheckRun", graphql_name="checkRun") + """The updated check run.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + +class UpdateCheckSuitePreferencesPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateCheckSuitePreferences""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The updated repository.""" + + +class UpdateDiscussionCommentPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + comment = sgqlc.types.Field("DiscussionComment", graphql_name="comment") + """The modified discussion comment.""" + + +class UpdateDiscussionPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateDiscussion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "discussion") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + discussion = sgqlc.types.Field("Discussion", graphql_name="discussion") + """The modified discussion.""" + + +class UpdateEnterpriseAdministratorRolePayload(sgqlc.types.Type): + """Autogenerated return type of UpdateEnterpriseAdministratorRole""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of changing the administrator's + role. + """ + + +class UpdateEnterpriseAllowPrivateRepositoryForkingSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseAllowPrivateRepositoryForkingSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated allow private repository forking + setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the allow private + repository forking setting. + """ + + +class UpdateEnterpriseDefaultRepositoryPermissionSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseDefaultRepositoryPermissionSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated base repository permission + setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the base repository + permission setting. + """ + + +class UpdateEnterpriseMembersCanChangeRepositoryVisibilitySettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanChangeRepositoryVisibilitySetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can change repository + visibility setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can change + repository visibility setting. + """ + + +class UpdateEnterpriseMembersCanCreateRepositoriesSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanCreateRepositoriesSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can create repositories + setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can create + repositories setting. + """ + + +class UpdateEnterpriseMembersCanDeleteIssuesSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanDeleteIssuesSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can delete issues setting.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can delete + issues setting. + """ + + +class UpdateEnterpriseMembersCanDeleteRepositoriesSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanDeleteRepositoriesSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can delete repositories + setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can delete + repositories setting. + """ + + +class UpdateEnterpriseMembersCanInviteCollaboratorsSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanInviteCollaboratorsSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can invite collaborators + setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can invite + collaborators setting. + """ + + +class UpdateEnterpriseMembersCanMakePurchasesSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanMakePurchasesSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can make purchases + setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can make + purchases setting. + """ + + +class UpdateEnterpriseMembersCanUpdateProtectedBranchesSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanUpdateProtectedBranchesSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can update protected + branches setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can update + protected branches setting. + """ + + +class UpdateEnterpriseMembersCanViewDependencyInsightsSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseMembersCanViewDependencyInsightsSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated members can view dependency + insights setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the members can view + dependency insights setting. + """ + + +class UpdateEnterpriseOrganizationProjectsSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseOrganizationProjectsSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated organization projects setting.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the organization + projects setting. + """ + + +class UpdateEnterpriseOwnerOrganizationRolePayload(sgqlc.types.Type): + """Autogenerated return type of UpdateEnterpriseOwnerOrganizationRole""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of changing the owner's + organization role. + """ + + +class UpdateEnterpriseProfilePayload(sgqlc.types.Type): + """Autogenerated return type of UpdateEnterpriseProfile""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The updated enterprise.""" + + +class UpdateEnterpriseRepositoryProjectsSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseRepositoryProjectsSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated repository projects setting.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the repository + projects setting. + """ + + +class UpdateEnterpriseTeamDiscussionsSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseTeamDiscussionsSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated team discussions setting.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the team discussions + setting. + """ + + +class UpdateEnterpriseTwoFactorAuthenticationRequiredSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateEnterpriseTwoFactorAuthenticationRequiredSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "enterprise", "message") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + enterprise = sgqlc.types.Field("Enterprise", graphql_name="enterprise") + """The enterprise with the updated two factor authentication required + setting. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the two factor + authentication required setting. + """ + + +class UpdateEnvironmentPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateEnvironment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "environment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + environment = sgqlc.types.Field("Environment", graphql_name="environment") + """The updated environment.""" + + +class UpdateIpAllowListEnabledSettingPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateIpAllowListEnabledSetting""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "owner") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + owner = sgqlc.types.Field("IpAllowListOwner", graphql_name="owner") + """The IP allow list owner on which the setting was updated.""" + + +class UpdateIpAllowListEntryPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateIpAllowListEntry""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "ip_allow_list_entry") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + ip_allow_list_entry = sgqlc.types.Field("IpAllowListEntry", graphql_name="ipAllowListEntry") + """The IP allow list entry that was updated.""" + + +class UpdateIpAllowListForInstalledAppsEnabledSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateIpAllowListForInstalledAppsEnabledSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "owner") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + owner = sgqlc.types.Field("IpAllowListOwner", graphql_name="owner") + """The IP allow list owner on which the setting was updated.""" + + +class UpdateIssueCommentPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateIssueComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "issue_comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue_comment = sgqlc.types.Field("IssueComment", graphql_name="issueComment") + """The updated comment.""" + + +class UpdateIssuePayload(sgqlc.types.Type): + """Autogenerated return type of UpdateIssue""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "issue") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + issue = sgqlc.types.Field("Issue", graphql_name="issue") + """The issue.""" + + +class UpdateNotificationRestrictionSettingPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateNotificationRestrictionSetting""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "owner") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + owner = sgqlc.types.Field("VerifiableDomainOwner", graphql_name="owner") + """The owner on which the setting was updated.""" + + +class UpdateOrganizationAllowPrivateRepositoryForkingSettingPayload(sgqlc.types.Type): + """Autogenerated return type of + UpdateOrganizationAllowPrivateRepositoryForkingSetting + """ + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "message", "organization") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + message = sgqlc.types.Field(String, graphql_name="message") + """A message confirming the result of updating the allow private + repository forking setting. + """ + + organization = sgqlc.types.Field("Organization", graphql_name="organization") + """The organization with the updated allow private repository forking + setting. + """ + + +class UpdateProjectCardPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateProjectCard""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project_card") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_card = sgqlc.types.Field("ProjectCard", graphql_name="projectCard") + """The updated ProjectCard.""" + + +class UpdateProjectColumnPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateProjectColumn""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project_column") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_column = sgqlc.types.Field("ProjectColumn", graphql_name="projectColumn") + """The updated project column.""" + + +class UpdateProjectDraftIssuePayload(sgqlc.types.Type): + """Autogenerated return type of UpdateProjectDraftIssue""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "draft_issue") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + draft_issue = sgqlc.types.Field("DraftIssue", graphql_name="draftIssue") + """The draft issue updated in the project.""" + + +class UpdateProjectNextItemFieldPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateProjectNextItemField""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project_next_item") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_next_item = sgqlc.types.Field("ProjectNextItem", graphql_name="projectNextItem") + """The updated item.""" + + +class UpdateProjectNextPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateProjectNext""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project_next") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project_next = sgqlc.types.Field("ProjectNext", graphql_name="projectNext") + """The updated Project.""" + + +class UpdateProjectPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateProject""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "project") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + project = sgqlc.types.Field("Project", graphql_name="project") + """The updated project.""" + + +class UpdatePullRequestBranchPayload(sgqlc.types.Type): + """Autogenerated return type of UpdatePullRequestBranch""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The updated pull request.""" + + +class UpdatePullRequestPayload(sgqlc.types.Type): + """Autogenerated return type of UpdatePullRequest""" + + __schema__ = github_schema + __field_names__ = ("actor", "client_mutation_id", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The updated pull request.""" + + +class UpdatePullRequestReviewCommentPayload(sgqlc.types.Type): + """Autogenerated return type of UpdatePullRequestReviewComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request_review_comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request_review_comment = sgqlc.types.Field("PullRequestReviewComment", graphql_name="pullRequestReviewComment") + """The updated comment.""" + + +class UpdatePullRequestReviewPayload(sgqlc.types.Type): + """Autogenerated return type of UpdatePullRequestReview""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "pull_request_review") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + pull_request_review = sgqlc.types.Field("PullRequestReview", graphql_name="pullRequestReview") + """The updated pull request review.""" + + +class UpdateRefPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateRef""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "ref") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """The updated Ref.""" + + +class UpdateRepositoryPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateRepository""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The updated repository.""" + + +class UpdateSponsorshipPreferencesPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateSponsorshipPreferences""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "sponsorship") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + sponsorship = sgqlc.types.Field("Sponsorship", graphql_name="sponsorship") + """The sponsorship that was updated.""" + + +class UpdateSubscriptionPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateSubscription""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "subscribable") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + subscribable = sgqlc.types.Field(Subscribable, graphql_name="subscribable") + """The input subscribable entity.""" + + +class UpdateTeamDiscussionCommentPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateTeamDiscussionComment""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "team_discussion_comment") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + team_discussion_comment = sgqlc.types.Field("TeamDiscussionComment", graphql_name="teamDiscussionComment") + """The updated comment.""" + + +class UpdateTeamDiscussionPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateTeamDiscussion""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "team_discussion") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + team_discussion = sgqlc.types.Field("TeamDiscussion", graphql_name="teamDiscussion") + """The updated discussion.""" + + +class UpdateTeamsRepositoryPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateTeamsRepository""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "repository", "teams") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository that was updated.""" + + teams = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null("Team")), graphql_name="teams") + """The teams granted permission on the repository.""" + + +class UpdateTopicsPayload(sgqlc.types.Type): + """Autogenerated return type of UpdateTopics""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "invalid_topic_names", "repository") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + invalid_topic_names = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="invalidTopicNames") + """Names of the provided topics that are not valid.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The updated repository.""" + + +class UserConnection(sgqlc.types.relay.Connection): + """The connection type for User.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("UserEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("User"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class UserContentEditConnection(sgqlc.types.relay.Connection): + """A list of edits to content.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("UserContentEditEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("UserContentEdit"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class UserContentEditEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("UserContentEdit", graphql_name="node") + """The item at the end of the edge.""" + + +class UserEdge(sgqlc.types.Type): + """Represents a user.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("User", graphql_name="node") + """The item at the end of the edge.""" + + +class UserEmailMetadata(sgqlc.types.Type): + """Email attributes from External Identity""" + + __schema__ = github_schema + __field_names__ = ("primary", "type", "value") + primary = sgqlc.types.Field(Boolean, graphql_name="primary") + """Boolean to identify primary emails""" + + type = sgqlc.types.Field(String, graphql_name="type") + """Type of email""" + + value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="value") + """Email id""" + + +class UserStatusConnection(sgqlc.types.relay.Connection): + """The connection type for UserStatus.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("UserStatusEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("UserStatus"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class UserStatusEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("UserStatus", graphql_name="node") + """The item at the end of the edge.""" + + +class VerifiableDomainConnection(sgqlc.types.relay.Connection): + """The connection type for VerifiableDomain.""" + + __schema__ = github_schema + __field_names__ = ("edges", "nodes", "page_info", "total_count") + edges = sgqlc.types.Field(sgqlc.types.list_of("VerifiableDomainEdge"), graphql_name="edges") + """A list of edges.""" + + nodes = sgqlc.types.Field(sgqlc.types.list_of("VerifiableDomain"), graphql_name="nodes") + """A list of nodes.""" + + page_info = sgqlc.types.Field(sgqlc.types.non_null(PageInfo), graphql_name="pageInfo") + """Information to aid in pagination.""" + + total_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalCount") + """Identifies the total count of items in the connection.""" + + +class VerifiableDomainEdge(sgqlc.types.Type): + """An edge in a connection.""" + + __schema__ = github_schema + __field_names__ = ("cursor", "node") + cursor = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cursor") + """A cursor for use in pagination.""" + + node = sgqlc.types.Field("VerifiableDomain", graphql_name="node") + """The item at the end of the edge.""" + + +class VerifyVerifiableDomainPayload(sgqlc.types.Type): + """Autogenerated return type of VerifyVerifiableDomain""" + + __schema__ = github_schema + __field_names__ = ("client_mutation_id", "domain") + client_mutation_id = sgqlc.types.Field(String, graphql_name="clientMutationId") + """A unique identifier for the client performing the mutation.""" + + domain = sgqlc.types.Field("VerifiableDomain", graphql_name="domain") + """The verifiable domain that was verified.""" + + +class Votable(sgqlc.types.Interface): + """A subject that may be upvoted.""" + + __schema__ = github_schema + __field_names__ = ("upvote_count", "viewer_can_upvote", "viewer_has_upvoted") + upvote_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="upvoteCount") + """Number of upvotes that this subject has received.""" + + viewer_can_upvote = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanUpvote") + """Whether or not the current user can add or remove an upvote on + this subject. + """ + + viewer_has_upvoted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerHasUpvoted") + """Whether or not the current user has already upvoted this subject.""" + + +class AddedToProjectEvent(sgqlc.types.Type, Node): + """Represents a 'added_to_project' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "database_id") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + +class App(sgqlc.types.Type, Node): + """A GitHub App.""" + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "database_id", + "description", + "ip_allow_list_entries", + "logo_background_color", + "logo_url", + "name", + "slug", + "updated_at", + "url", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The description of the app.""" + + ip_allow_list_entries = sgqlc.types.Field( + sgqlc.types.non_null(IpAllowListEntryConnection), + graphql_name="ipAllowListEntries", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg( + IpAllowListEntryOrder, graphql_name="orderBy", default={"field": "ALLOW_LIST_VALUE", "direction": "ASC"} + ), + ), + ) + ), + ) + """The IP addresses of the app. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`IpAllowListEntryOrder`): Ordering options for IP + allow list entries returned. (default: `{field: + ALLOW_LIST_VALUE, direction: ASC}`) + """ + + logo_background_color = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="logoBackgroundColor") + """The hex color code, without the leading '#', for the logo + background. + """ + + logo_url = sgqlc.types.Field( + sgqlc.types.non_null(URI), + graphql_name="logoUrl", + args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=None)),)), + ) + """A URL pointing to the app's logo. + + Arguments: + + * `size` (`Int`): The size of the resulting image. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the app.""" + + slug = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="slug") + """A slug based on the name of the app for use in URLs.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The URL to the app's homepage.""" + + +class AssignedEvent(sgqlc.types.Type, Node): + """Represents an 'assigned' event on any assignable object.""" + + __schema__ = github_schema + __field_names__ = ("actor", "assignable", "assignee", "created_at") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + assignable = sgqlc.types.Field(sgqlc.types.non_null(Assignable), graphql_name="assignable") + """Identifies the assignable associated with the event.""" + + assignee = sgqlc.types.Field("Assignee", graphql_name="assignee") + """Identifies the user or mannequin that was assigned.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + +class AutoMergeDisabledEvent(sgqlc.types.Type, Node): + """Represents a 'auto_merge_disabled' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "disabler", "pull_request", "reason", "reason_code") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + disabler = sgqlc.types.Field("User", graphql_name="disabler") + """The user who disabled auto-merge for this Pull Request""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """PullRequest referenced by event""" + + reason = sgqlc.types.Field(String, graphql_name="reason") + """The reason auto-merge was disabled""" + + reason_code = sgqlc.types.Field(String, graphql_name="reasonCode") + """The reason_code relating to why auto-merge was disabled""" + + +class AutoMergeEnabledEvent(sgqlc.types.Type, Node): + """Represents a 'auto_merge_enabled' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "enabler", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + enabler = sgqlc.types.Field("User", graphql_name="enabler") + """The user who enabled auto-merge for this Pull Request""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class AutoRebaseEnabledEvent(sgqlc.types.Type, Node): + """Represents a 'auto_rebase_enabled' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "enabler", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + enabler = sgqlc.types.Field("User", graphql_name="enabler") + """The user who enabled auto-merge (rebase) for this Pull Request""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class AutoSquashEnabledEvent(sgqlc.types.Type, Node): + """Represents a 'auto_squash_enabled' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "enabler", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + enabler = sgqlc.types.Field("User", graphql_name="enabler") + """The user who enabled auto-merge (squash) for this Pull Request""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class AutomaticBaseChangeFailedEvent(sgqlc.types.Type, Node): + """Represents a 'automatic_base_change_failed' event on a given pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "new_base", "old_base", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + new_base = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="newBase") + """The new base for this PR""" + + old_base = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="oldBase") + """The old base for this PR""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class AutomaticBaseChangeSucceededEvent(sgqlc.types.Type, Node): + """Represents a 'automatic_base_change_succeeded' event on a given + pull request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "new_base", "old_base", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + new_base = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="newBase") + """The new base for this PR""" + + old_base = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="oldBase") + """The old base for this PR""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class BaseRefChangedEvent(sgqlc.types.Type, Node): + """Represents a 'base_ref_changed' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "current_ref_name", "database_id", "previous_ref_name", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + current_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="currentRefName") + """Identifies the name of the base ref for the pull request after it + was changed. + """ + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + previous_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="previousRefName") + """Identifies the name of the base ref for the pull request before it + was changed. + """ + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class BaseRefDeletedEvent(sgqlc.types.Type, Node): + """Represents a 'base_ref_deleted' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "base_ref_name", "created_at", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + base_ref_name = sgqlc.types.Field(String, graphql_name="baseRefName") + """Identifies the name of the Ref associated with the + `base_ref_deleted` event. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class BaseRefForcePushedEvent(sgqlc.types.Type, Node): + """Represents a 'base_ref_force_pushed' event on a given pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "after_commit", "before_commit", "created_at", "pull_request", "ref") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + after_commit = sgqlc.types.Field("Commit", graphql_name="afterCommit") + """Identifies the after commit SHA for the 'base_ref_force_pushed' + event. + """ + + before_commit = sgqlc.types.Field("Commit", graphql_name="beforeCommit") + """Identifies the before commit SHA for the 'base_ref_force_pushed' + event. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """Identifies the fully qualified ref name for the + 'base_ref_force_pushed' event. + """ + + +class Blob(sgqlc.types.Type, GitObject, Node): + """Represents a Git blob.""" + + __schema__ = github_schema + __field_names__ = ("byte_size", "is_binary", "is_truncated", "text") + byte_size = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="byteSize") + """Byte size of Blob object""" + + is_binary = sgqlc.types.Field(Boolean, graphql_name="isBinary") + """Indicates whether the Blob is binary or text. Returns null if + unable to determine the encoding. + """ + + is_truncated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isTruncated") + """Indicates whether the contents is truncated""" + + text = sgqlc.types.Field(String, graphql_name="text") + """UTF8 text data or null if the Blob is binary""" + + +class Bot(sgqlc.types.Type, Node, Actor, UniformResourceLocatable): + """A special type of user which takes actions on behalf of GitHub + Apps. + """ + + __schema__ = github_schema + __field_names__ = ("created_at", "database_id", "updated_at") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class BranchProtectionRule(sgqlc.types.Type, Node): + """A branch protection rule.""" + + __schema__ = github_schema + __field_names__ = ( + "allows_deletions", + "allows_force_pushes", + "blocks_creations", + "branch_protection_rule_conflicts", + "bypass_force_push_allowances", + "bypass_pull_request_allowances", + "creator", + "database_id", + "dismisses_stale_reviews", + "is_admin_enforced", + "matching_refs", + "pattern", + "push_allowances", + "repository", + "required_approving_review_count", + "required_status_check_contexts", + "required_status_checks", + "requires_approving_reviews", + "requires_code_owner_reviews", + "requires_commit_signatures", + "requires_conversation_resolution", + "requires_linear_history", + "requires_status_checks", + "requires_strict_status_checks", + "restricts_pushes", + "restricts_review_dismissals", + "review_dismissal_allowances", + ) + allows_deletions = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="allowsDeletions") + """Can this branch be deleted.""" + + allows_force_pushes = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="allowsForcePushes") + """Are force pushes allowed on this branch.""" + + blocks_creations = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="blocksCreations") + """Is branch creation a protected operation.""" + + branch_protection_rule_conflicts = sgqlc.types.Field( + sgqlc.types.non_null(BranchProtectionRuleConflictConnection), + graphql_name="branchProtectionRuleConflicts", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of conflicts matching branches protection rule and other + branch protection rules + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + bypass_force_push_allowances = sgqlc.types.Field( + sgqlc.types.non_null(BypassForcePushAllowanceConnection), + graphql_name="bypassForcePushAllowances", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of actors able to force push for this branch protection + rule. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + bypass_pull_request_allowances = sgqlc.types.Field( + sgqlc.types.non_null(BypassPullRequestAllowanceConnection), + graphql_name="bypassPullRequestAllowances", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of actors able to bypass PRs for this branch protection + rule. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who created this branch protection rule.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + dismisses_stale_reviews = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="dismissesStaleReviews") + """Will new commits pushed to matching branches dismiss pull request + review approvals. + """ + + is_admin_enforced = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isAdminEnforced") + """Can admins overwrite branch protection.""" + + matching_refs = sgqlc.types.Field( + sgqlc.types.non_null(RefConnection), + graphql_name="matchingRefs", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Repository refs that are protected by this rule + + Arguments: + + * `query` (`String`): Filters refs with query on name + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pattern = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="pattern") + """Identifies the protection rule pattern.""" + + push_allowances = sgqlc.types.Field( + sgqlc.types.non_null(PushAllowanceConnection), + graphql_name="pushAllowances", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list push allowances for this branch protection rule. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository associated with this branch protection rule.""" + + required_approving_review_count = sgqlc.types.Field(Int, graphql_name="requiredApprovingReviewCount") + """Number of approving reviews required to update matching branches.""" + + required_status_check_contexts = sgqlc.types.Field(sgqlc.types.list_of(String), graphql_name="requiredStatusCheckContexts") + """List of required status check contexts that must pass for commits + to be accepted to matching branches. + """ + + required_status_checks = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(RequiredStatusCheckDescription)), graphql_name="requiredStatusChecks" + ) + """List of required status checks that must pass for commits to be + accepted to matching branches. + """ + + requires_approving_reviews = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresApprovingReviews") + """Are approving reviews required to update matching branches.""" + + requires_code_owner_reviews = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresCodeOwnerReviews") + """Are reviews from code owners required to update matching branches.""" + + requires_commit_signatures = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresCommitSignatures") + """Are commits required to be signed.""" + + requires_conversation_resolution = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresConversationResolution") + """Are conversations required to be resolved before merging.""" + + requires_linear_history = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresLinearHistory") + """Are merge commits prohibited from being pushed to this branch.""" + + requires_status_checks = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresStatusChecks") + """Are status checks required to update matching branches.""" + + requires_strict_status_checks = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="requiresStrictStatusChecks") + """Are branches required to be up to date before merging.""" + + restricts_pushes = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="restrictsPushes") + """Is pushing to matching branches restricted.""" + + restricts_review_dismissals = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="restrictsReviewDismissals") + """Is dismissal of pull request reviews restricted.""" + + review_dismissal_allowances = sgqlc.types.Field( + sgqlc.types.non_null(ReviewDismissalAllowanceConnection), + graphql_name="reviewDismissalAllowances", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list review dismissal allowances for this branch protection + rule. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class BypassForcePushAllowance(sgqlc.types.Type, Node): + """A user, team, or app who has the ability to bypass a force push + requirement on a protected branch. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "branch_protection_rule") + actor = sgqlc.types.Field("BranchActorAllowanceActor", graphql_name="actor") + """The actor that can force push.""" + + branch_protection_rule = sgqlc.types.Field(BranchProtectionRule, graphql_name="branchProtectionRule") + """Identifies the branch protection rule associated with the allowed + user, team, or app. + """ + + +class BypassPullRequestAllowance(sgqlc.types.Type, Node): + """A user, team, or app who has the ability to bypass a pull request + requirement on a protected branch. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "branch_protection_rule") + actor = sgqlc.types.Field("BranchActorAllowanceActor", graphql_name="actor") + """The actor that can bypass.""" + + branch_protection_rule = sgqlc.types.Field(BranchProtectionRule, graphql_name="branchProtectionRule") + """Identifies the branch protection rule associated with the allowed + user, team, or app. + """ + + +class CWE(sgqlc.types.Type, Node): + """A common weakness enumeration""" + + __schema__ = github_schema + __field_names__ = ("cwe_id", "description", "name") + cwe_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="cweId") + """The id of the CWE""" + + description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description") + """A detailed description of this CWE""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of this CWE""" + + +class CheckRun(sgqlc.types.Type, Node, UniformResourceLocatable, RequirableByPullRequest): + """A check run.""" + + __schema__ = github_schema + __field_names__ = ( + "annotations", + "check_suite", + "completed_at", + "conclusion", + "database_id", + "deployment", + "details_url", + "external_id", + "name", + "pending_deployment_request", + "permalink", + "repository", + "started_at", + "status", + "steps", + "summary", + "text", + "title", + ) + annotations = sgqlc.types.Field( + CheckAnnotationConnection, + graphql_name="annotations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The check run's annotations + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + check_suite = sgqlc.types.Field(sgqlc.types.non_null("CheckSuite"), graphql_name="checkSuite") + """The check suite that this run is a part of.""" + + completed_at = sgqlc.types.Field(DateTime, graphql_name="completedAt") + """Identifies the date and time when the check run was completed.""" + + conclusion = sgqlc.types.Field(CheckConclusionState, graphql_name="conclusion") + """The conclusion of the check run.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + deployment = sgqlc.types.Field("Deployment", graphql_name="deployment") + """The corresponding deployment for this job, if any""" + + details_url = sgqlc.types.Field(URI, graphql_name="detailsUrl") + """The URL from which to find full details of the check run on the + integrator's site. + """ + + external_id = sgqlc.types.Field(String, graphql_name="externalId") + """A reference for the check run on the integrator's system.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the check for this check run.""" + + pending_deployment_request = sgqlc.types.Field(DeploymentRequest, graphql_name="pendingDeploymentRequest") + """Information about a pending deployment, if any, in this check run""" + + permalink = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="permalink") + """The permalink to the check run summary.""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository associated with this check run.""" + + started_at = sgqlc.types.Field(DateTime, graphql_name="startedAt") + """Identifies the date and time when the check run was started.""" + + status = sgqlc.types.Field(sgqlc.types.non_null(CheckStatusState), graphql_name="status") + """The current status of the check run.""" + + steps = sgqlc.types.Field( + CheckStepConnection, + graphql_name="steps", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("number", sgqlc.types.Arg(Int, graphql_name="number", default=None)), + ) + ), + ) + """The check run's steps + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `number` (`Int`): Step number + """ + + summary = sgqlc.types.Field(String, graphql_name="summary") + """A string representing the check run's summary""" + + text = sgqlc.types.Field(String, graphql_name="text") + """A string representing the check run's text""" + + title = sgqlc.types.Field(String, graphql_name="title") + """A string representing the check run""" + + +class CheckSuite(sgqlc.types.Type, Node): + """A check suite.""" + + __schema__ = github_schema + __field_names__ = ( + "app", + "branch", + "check_runs", + "commit", + "conclusion", + "created_at", + "creator", + "database_id", + "matching_pull_requests", + "push", + "repository", + "resource_path", + "status", + "updated_at", + "url", + "workflow_run", + ) + app = sgqlc.types.Field(App, graphql_name="app") + """The GitHub App which created this check suite.""" + + branch = sgqlc.types.Field("Ref", graphql_name="branch") + """The name of the branch for this check suite.""" + + check_runs = sgqlc.types.Field( + CheckRunConnection, + graphql_name="checkRuns", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("filter_by", sgqlc.types.Arg(CheckRunFilter, graphql_name="filterBy", default=None)), + ) + ), + ) + """The check runs associated with a check suite. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `filter_by` (`CheckRunFilter`): Filters the check runs by this + type. + """ + + commit = sgqlc.types.Field(sgqlc.types.non_null("Commit"), graphql_name="commit") + """The commit for this check suite""" + + conclusion = sgqlc.types.Field(CheckConclusionState, graphql_name="conclusion") + """The conclusion of this check suite.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field("User", graphql_name="creator") + """The user who triggered the check suite.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + matching_pull_requests = sgqlc.types.Field( + PullRequestConnection, + graphql_name="matchingPullRequests", + args=sgqlc.types.ArgDict( + ( + ( + "states", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PullRequestState)), graphql_name="states", default=None), + ), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("head_ref_name", sgqlc.types.Arg(String, graphql_name="headRefName", default=None)), + ("base_ref_name", sgqlc.types.Arg(String, graphql_name="baseRefName", default=None)), + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of open pull requests matching the check suite. + + Arguments: + + * `states` (`[PullRequestState!]`): A list of states to filter the + pull requests by. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `head_ref_name` (`String`): The head ref name to filter the pull + requests by. + * `base_ref_name` (`String`): The base ref name to filter the pull + requests by. + * `order_by` (`IssueOrder`): Ordering options for pull requests + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + push = sgqlc.types.Field("Push", graphql_name="push") + """The push that triggered this check suite.""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository associated with this check suite.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this check suite""" + + status = sgqlc.types.Field(sgqlc.types.non_null(CheckStatusState), graphql_name="status") + """The status of this check suite.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this check suite""" + + workflow_run = sgqlc.types.Field("WorkflowRun", graphql_name="workflowRun") + """The workflow run associated with this check suite.""" + + +class ClosedEvent(sgqlc.types.Type, Node, UniformResourceLocatable): + """Represents a 'closed' event on any `Closable`.""" + + __schema__ = github_schema + __field_names__ = ("actor", "closable", "closer", "created_at", "state_reason") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + closable = sgqlc.types.Field(sgqlc.types.non_null(Closable), graphql_name="closable") + """Object that was closed.""" + + closer = sgqlc.types.Field("Closer", graphql_name="closer") + """Object which triggered the creation of this event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + state_reason = sgqlc.types.Field(IssueStateReason, graphql_name="stateReason") + """The reason the issue state was changed to closed.""" + + +class CodeOfConduct(sgqlc.types.Type, Node): + """The Code of Conduct for a repository""" + + __schema__ = github_schema + __field_names__ = ("body", "key", "name", "resource_path", "url") + body = sgqlc.types.Field(String, graphql_name="body") + """The body of the Code of Conduct""" + + key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key") + """The key for the Code of Conduct""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The formal name of the Code of Conduct""" + + resource_path = sgqlc.types.Field(URI, graphql_name="resourcePath") + """The HTTP path for this Code of Conduct""" + + url = sgqlc.types.Field(URI, graphql_name="url") + """The HTTP URL for this Code of Conduct""" + + +class CommentDeletedEvent(sgqlc.types.Type, Node): + """Represents a 'comment_deleted' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "database_id", "deleted_comment_author") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + deleted_comment_author = sgqlc.types.Field(Actor, graphql_name="deletedCommentAuthor") + """The user who authored the deleted comment.""" + + +class Commit(sgqlc.types.Type, Node, GitObject, Subscribable, UniformResourceLocatable): + """Represents a Git commit.""" + + __schema__ = github_schema + __field_names__ = ( + "additions", + "associated_pull_requests", + "author", + "authored_by_committer", + "authored_date", + "authors", + "blame", + "changed_files", + "check_suites", + "comments", + "committed_date", + "committed_via_web", + "committer", + "deletions", + "deployments", + "file", + "history", + "message", + "message_body", + "message_body_html", + "message_headline", + "message_headline_html", + "on_behalf_of", + "parents", + "pushed_date", + "signature", + "status", + "status_check_rollup", + "submodules", + "tarball_url", + "tree", + "tree_resource_path", + "tree_url", + "zipball_url", + ) + additions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="additions") + """The number of additions in this commit.""" + + associated_pull_requests = sgqlc.types.Field( + PullRequestConnection, + graphql_name="associatedPullRequests", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg(PullRequestOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "ASC"}), + ), + ) + ), + ) + """The merged Pull Request that introduced the commit to the + repository. If the commit is not present in the default branch, + additionally returns open Pull Requests associated with the commit + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`PullRequestOrder`): Ordering options for pull + requests. (default: `{field: CREATED_AT, direction: ASC}`) + """ + + author = sgqlc.types.Field(GitActor, graphql_name="author") + """Authorship details of the commit.""" + + authored_by_committer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="authoredByCommitter") + """Check if the committer and the author match.""" + + authored_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="authoredDate") + """The datetime when this commit was authored.""" + + authors = sgqlc.types.Field( + sgqlc.types.non_null(GitActorConnection), + graphql_name="authors", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The list of authors for this commit based on the git author and + the Co-authored-by message trailer. The git author will always be + first. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + blame = sgqlc.types.Field( + sgqlc.types.non_null(Blame), + graphql_name="blame", + args=sgqlc.types.ArgDict((("path", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="path", default=None)),)), + ) + """Fetches `git blame` information. + + Arguments: + + * `path` (`String!`): The file whose Git blame information you + want. + """ + + changed_files = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="changedFiles") + """The number of changed files in this commit.""" + + check_suites = sgqlc.types.Field( + CheckSuiteConnection, + graphql_name="checkSuites", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("filter_by", sgqlc.types.Arg(CheckSuiteFilter, graphql_name="filterBy", default=None)), + ) + ), + ) + """The check suites associated with a commit. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `filter_by` (`CheckSuiteFilter`): Filters the check suites by + this type. + """ + + comments = sgqlc.types.Field( + sgqlc.types.non_null(CommitCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Comments made on the commit. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + committed_date = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="committedDate") + """The datetime when this commit was committed.""" + + committed_via_web = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="committedViaWeb") + """Check if committed via GitHub web UI.""" + + committer = sgqlc.types.Field(GitActor, graphql_name="committer") + """Committer details of the commit.""" + + deletions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="deletions") + """The number of deletions in this commit.""" + + deployments = sgqlc.types.Field( + DeploymentConnection, + graphql_name="deployments", + args=sgqlc.types.ArgDict( + ( + ( + "environments", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="environments", default=None), + ), + ("order_by", sgqlc.types.Arg(DeploymentOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "ASC"})), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The deployments associated with a commit. + + Arguments: + + * `environments` (`[String!]`): Environments to list deployments + for + * `order_by` (`DeploymentOrder`): Ordering options for deployments + returned from the connection. (default: `{field: CREATED_AT, + direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + file = sgqlc.types.Field( + TreeEntry, + graphql_name="file", + args=sgqlc.types.ArgDict((("path", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="path", default=None)),)), + ) + """The tree entry representing the file located at the given path. + + Arguments: + + * `path` (`String!`): The path for the file + """ + + history = sgqlc.types.Field( + sgqlc.types.non_null(CommitHistoryConnection), + graphql_name="history", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("path", sgqlc.types.Arg(String, graphql_name="path", default=None)), + ("author", sgqlc.types.Arg(CommitAuthor, graphql_name="author", default=None)), + ("since", sgqlc.types.Arg(GitTimestamp, graphql_name="since", default=None)), + ("until", sgqlc.types.Arg(GitTimestamp, graphql_name="until", default=None)), + ) + ), + ) + """The linear commit history starting from (and including) this + commit, in the same order as `git log`. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `path` (`String`): If non-null, filters history to only show + commits touching files under this path. + * `author` (`CommitAuthor`): If non-null, filters history to only + show commits with matching authorship. + * `since` (`GitTimestamp`): Allows specifying a beginning time or + date for fetching commits. + * `until` (`GitTimestamp`): Allows specifying an ending time or + date for fetching commits. + """ + + message = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="message") + """The Git commit message""" + + message_body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="messageBody") + """The Git commit message body""" + + message_body_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="messageBodyHTML") + """The commit message body rendered to HTML.""" + + message_headline = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="messageHeadline") + """The Git commit message headline""" + + message_headline_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="messageHeadlineHTML") + """The commit message headline rendered to HTML.""" + + on_behalf_of = sgqlc.types.Field("Organization", graphql_name="onBehalfOf") + """The organization this commit was made on behalf of.""" + + parents = sgqlc.types.Field( + sgqlc.types.non_null(CommitConnection), + graphql_name="parents", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The parents of a commit. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pushed_date = sgqlc.types.Field(DateTime, graphql_name="pushedDate") + """The datetime when this commit was pushed.""" + + signature = sgqlc.types.Field(GitSignature, graphql_name="signature") + """Commit signing information, if present.""" + + status = sgqlc.types.Field("Status", graphql_name="status") + """Status information for this commit""" + + status_check_rollup = sgqlc.types.Field("StatusCheckRollup", graphql_name="statusCheckRollup") + """Check and Status rollup information for this commit.""" + + submodules = sgqlc.types.Field( + sgqlc.types.non_null(SubmoduleConnection), + graphql_name="submodules", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Returns a list of all submodules in this repository as of this + Commit parsed from the .gitmodules file. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + tarball_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="tarballUrl") + """Returns a URL to download a tarball archive for a repository. + Note: For private repositories, these links are temporary and + expire after five minutes. + """ + + tree = sgqlc.types.Field(sgqlc.types.non_null("Tree"), graphql_name="tree") + """Commit's root Tree""" + + tree_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="treeResourcePath") + """The HTTP path for the tree of this commit""" + + tree_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="treeUrl") + """The HTTP URL for the tree of this commit""" + + zipball_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="zipballUrl") + """Returns a URL to download a zipball archive for a repository. + Note: For private repositories, these links are temporary and + expire after five minutes. + """ + + +class CommitComment(sgqlc.types.Type, Node, Comment, Deletable, Minimizable, Updatable, UpdatableComment, Reactable, RepositoryNode): + """Represents a comment on a given Commit.""" + + __schema__ = github_schema + __field_names__ = ("commit", "path", "position", "resource_path", "url") + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """Identifies the commit associated with the comment, if the commit + exists. + """ + + path = sgqlc.types.Field(String, graphql_name="path") + """Identifies the file path associated with the comment.""" + + position = sgqlc.types.Field(Int, graphql_name="position") + """Identifies the line position associated with the comment.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path permalink for this commit comment.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL permalink for this commit comment.""" + + +class CommitCommentThread(sgqlc.types.Type, Node, RepositoryNode): + """A thread of comments on a commit.""" + + __schema__ = github_schema + __field_names__ = ("comments", "commit", "path", "position") + comments = sgqlc.types.Field( + sgqlc.types.non_null(CommitCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The comments that exist in this thread. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """The commit the comments were made on.""" + + path = sgqlc.types.Field(String, graphql_name="path") + """The file the comments were made on.""" + + position = sgqlc.types.Field(Int, graphql_name="position") + """The position in the diff for the commit that the comment was made + on. + """ + + +class ConnectedEvent(sgqlc.types.Type, Node): + """Represents a 'connected' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "is_cross_repository", "source", "subject") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + is_cross_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCrossRepository") + """Reference originated in a different repository.""" + + source = sgqlc.types.Field(sgqlc.types.non_null("ReferencedSubject"), graphql_name="source") + """Issue or pull request that made the reference.""" + + subject = sgqlc.types.Field(sgqlc.types.non_null("ReferencedSubject"), graphql_name="subject") + """Issue or pull request which was connected.""" + + +class ConvertToDraftEvent(sgqlc.types.Type, Node, UniformResourceLocatable): + """Represents a 'convert_to_draft' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class ConvertedNoteToIssueEvent(sgqlc.types.Type, Node): + """Represents a 'converted_note_to_issue' event on a given issue or + pull request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "database_id") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + +class ConvertedToDiscussionEvent(sgqlc.types.Type, Node): + """Represents a 'converted_to_discussion' event on a given issue.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "discussion") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + discussion = sgqlc.types.Field("Discussion", graphql_name="discussion") + """The discussion that the issue was converted into.""" + + +class CreatedCommitContribution(sgqlc.types.Type, Contribution): + """Represents the contribution a user made by committing to a + repository. + """ + + __schema__ = github_schema + __field_names__ = ("commit_count", "repository") + commit_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="commitCount") + """How many commits were made on this day to this repository by the + user. + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository the user made a commit in.""" + + +class CreatedIssueContribution(sgqlc.types.Type, Contribution): + """Represents the contribution a user made on GitHub by opening an + issue. + """ + + __schema__ = github_schema + __field_names__ = ("issue",) + issue = sgqlc.types.Field(sgqlc.types.non_null("Issue"), graphql_name="issue") + """The issue that was opened.""" + + +class CreatedPullRequestContribution(sgqlc.types.Type, Contribution): + """Represents the contribution a user made on GitHub by opening a + pull request. + """ + + __schema__ = github_schema + __field_names__ = ("pull_request",) + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """The pull request that was opened.""" + + +class CreatedPullRequestReviewContribution(sgqlc.types.Type, Contribution): + """Represents the contribution a user made by leaving a review on a + pull request. + """ + + __schema__ = github_schema + __field_names__ = ("pull_request", "pull_request_review", "repository") + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """The pull request the user reviewed.""" + + pull_request_review = sgqlc.types.Field(sgqlc.types.non_null("PullRequestReview"), graphql_name="pullRequestReview") + """The review the user left on the pull request.""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository containing the pull request that the user reviewed.""" + + +class CreatedRepositoryContribution(sgqlc.types.Type, Contribution): + """Represents the contribution a user made on GitHub by creating a + repository. + """ + + __schema__ = github_schema + __field_names__ = ("repository",) + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository that was created.""" + + +class CrossReferencedEvent(sgqlc.types.Type, UniformResourceLocatable, Node): + """Represents a mention made by one issue or pull request to another.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "is_cross_repository", "referenced_at", "source", "target", "will_close_target") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + is_cross_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCrossRepository") + """Reference originated in a different repository.""" + + referenced_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="referencedAt") + """Identifies when the reference was made.""" + + source = sgqlc.types.Field(sgqlc.types.non_null("ReferencedSubject"), graphql_name="source") + """Issue or pull request that made the reference.""" + + target = sgqlc.types.Field(sgqlc.types.non_null("ReferencedSubject"), graphql_name="target") + """Issue or pull request to which the reference was made.""" + + will_close_target = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="willCloseTarget") + """Checks if the target will be closed when the source is merged.""" + + +class DemilestonedEvent(sgqlc.types.Type, Node): + """Represents a 'demilestoned' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "milestone_title", "subject") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + milestone_title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="milestoneTitle") + """Identifies the milestone title associated with the 'demilestoned' + event. + """ + + subject = sgqlc.types.Field(sgqlc.types.non_null("MilestoneItem"), graphql_name="subject") + """Object referenced by event.""" + + +class DependabotUpdate(sgqlc.types.Type, RepositoryNode): + """A Dependabot Update for a dependency in a repository""" + + __schema__ = github_schema + __field_names__ = ("error", "pull_request") + error = sgqlc.types.Field(DependabotUpdateError, graphql_name="error") + """The error from a dependency update""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """The associated pull request""" + + +class DeployKey(sgqlc.types.Type, Node): + """A repository deploy key.""" + + __schema__ = github_schema + __field_names__ = ("created_at", "key", "read_only", "title", "verified") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key") + """The deploy key.""" + + read_only = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="readOnly") + """Whether or not the deploy key is read only.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The deploy key title.""" + + verified = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="verified") + """Whether or not the deploy key has been verified.""" + + +class DeployedEvent(sgqlc.types.Type, Node): + """Represents a 'deployed' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "database_id", "deployment", "pull_request", "ref") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + deployment = sgqlc.types.Field(sgqlc.types.non_null("Deployment"), graphql_name="deployment") + """The deployment associated with the 'deployed' event.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """The ref associated with the 'deployed' event.""" + + +class Deployment(sgqlc.types.Type, Node): + """Represents triggered deployment instance.""" + + __schema__ = github_schema + __field_names__ = ( + "commit", + "commit_oid", + "created_at", + "creator", + "database_id", + "description", + "environment", + "latest_environment", + "latest_status", + "original_environment", + "payload", + "ref", + "repository", + "state", + "statuses", + "task", + "updated_at", + ) + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """Identifies the commit sha of the deployment.""" + + commit_oid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="commitOid") + """Identifies the oid of the deployment commit, even if the commit + has been deleted. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(sgqlc.types.non_null(Actor), graphql_name="creator") + """Identifies the actor who triggered the deployment.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The deployment description.""" + + environment = sgqlc.types.Field(String, graphql_name="environment") + """The latest environment to which this deployment was made.""" + + latest_environment = sgqlc.types.Field(String, graphql_name="latestEnvironment") + """The latest environment to which this deployment was made.""" + + latest_status = sgqlc.types.Field("DeploymentStatus", graphql_name="latestStatus") + """The latest status of this deployment.""" + + original_environment = sgqlc.types.Field(String, graphql_name="originalEnvironment") + """The original environment to which this deployment was made.""" + + payload = sgqlc.types.Field(String, graphql_name="payload") + """Extra information that a deployment system might need.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """Identifies the Ref of the deployment, if the deployment was + created by ref. + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """Identifies the repository associated with the deployment.""" + + state = sgqlc.types.Field(DeploymentState, graphql_name="state") + """The current state of the deployment.""" + + statuses = sgqlc.types.Field( + DeploymentStatusConnection, + graphql_name="statuses", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of statuses associated with the deployment. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + task = sgqlc.types.Field(String, graphql_name="task") + """The deployment task.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class DeploymentEnvironmentChangedEvent(sgqlc.types.Type, Node): + """Represents a 'deployment_environment_changed' event on a given + pull request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "deployment_status", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + deployment_status = sgqlc.types.Field(sgqlc.types.non_null("DeploymentStatus"), graphql_name="deploymentStatus") + """The deployment status that updated the deployment environment.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class DeploymentReview(sgqlc.types.Type, Node): + """A deployment review.""" + + __schema__ = github_schema + __field_names__ = ("comment", "database_id", "environments", "state", "user") + comment = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="comment") + """The comment the user left.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + environments = sgqlc.types.Field( + sgqlc.types.non_null(EnvironmentConnection), + graphql_name="environments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The environments approved or rejected + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + state = sgqlc.types.Field(sgqlc.types.non_null(DeploymentReviewState), graphql_name="state") + """The decision of the user.""" + + user = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="user") + """The user that reviewed the deployment.""" + + +class DeploymentStatus(sgqlc.types.Type, Node): + """Describes the status of a given deployment attempt.""" + + __schema__ = github_schema + __field_names__ = ("created_at", "creator", "deployment", "description", "environment_url", "log_url", "state", "updated_at") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(sgqlc.types.non_null(Actor), graphql_name="creator") + """Identifies the actor who triggered the deployment.""" + + deployment = sgqlc.types.Field(sgqlc.types.non_null(Deployment), graphql_name="deployment") + """Identifies the deployment associated with status.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """Identifies the description of the deployment.""" + + environment_url = sgqlc.types.Field(URI, graphql_name="environmentUrl") + """Identifies the environment URL of the deployment.""" + + log_url = sgqlc.types.Field(URI, graphql_name="logUrl") + """Identifies the log URL of the deployment.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(DeploymentStatusState), graphql_name="state") + """Identifies the current state of the deployment.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class DisconnectedEvent(sgqlc.types.Type, Node): + """Represents a 'disconnected' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "is_cross_repository", "source", "subject") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + is_cross_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCrossRepository") + """Reference originated in a different repository.""" + + source = sgqlc.types.Field(sgqlc.types.non_null("ReferencedSubject"), graphql_name="source") + """Issue or pull request from which the issue was disconnected.""" + + subject = sgqlc.types.Field(sgqlc.types.non_null("ReferencedSubject"), graphql_name="subject") + """Issue or pull request which was disconnected.""" + + +class Discussion( + sgqlc.types.Type, Comment, Updatable, Deletable, Labelable, Lockable, RepositoryNode, Subscribable, Reactable, Votable, Node +): + """A discussion in a repository.""" + + __schema__ = github_schema + __field_names__ = ( + "answer", + "answer_chosen_at", + "answer_chosen_by", + "category", + "comments", + "number", + "poll", + "resource_path", + "title", + "url", + ) + answer = sgqlc.types.Field("DiscussionComment", graphql_name="answer") + """The comment chosen as this discussion's answer, if any.""" + + answer_chosen_at = sgqlc.types.Field(DateTime, graphql_name="answerChosenAt") + """The time when a user chose this discussion's answer, if answered.""" + + answer_chosen_by = sgqlc.types.Field(Actor, graphql_name="answerChosenBy") + """The user who chose this discussion's answer, if answered.""" + + category = sgqlc.types.Field(sgqlc.types.non_null("DiscussionCategory"), graphql_name="category") + """The category for this discussion.""" + + comments = sgqlc.types.Field( + sgqlc.types.non_null(DiscussionCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The replies to the discussion. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """The number identifying this discussion within the repository.""" + + poll = sgqlc.types.Field("DiscussionPoll", graphql_name="poll") + """The poll associated with this discussion, if one exists.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The path for this discussion.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of this discussion.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The URL for this discussion.""" + + +class DiscussionCategory(sgqlc.types.Type, Node, RepositoryNode): + """A category for discussions in a repository.""" + + __schema__ = github_schema + __field_names__ = ("created_at", "description", "emoji", "emoji_html", "is_answerable", "name", "updated_at") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """A description of this category.""" + + emoji = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="emoji") + """An emoji representing this category.""" + + emoji_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="emojiHTML") + """This category's emoji rendered as HTML.""" + + is_answerable = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isAnswerable") + """Whether or not discussions in this category support choosing an + answer with the markDiscussionCommentAsAnswer mutation. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of this category.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class DiscussionComment(sgqlc.types.Type, Comment, Deletable, Minimizable, Updatable, UpdatableComment, Reactable, Votable, Node): + """A comment on a discussion.""" + + __schema__ = github_schema + __field_names__ = ( + "deleted_at", + "discussion", + "is_answer", + "replies", + "reply_to", + "resource_path", + "url", + "viewer_can_mark_as_answer", + "viewer_can_unmark_as_answer", + ) + deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt") + """The time when this replied-to comment was deleted""" + + discussion = sgqlc.types.Field(Discussion, graphql_name="discussion") + """The discussion this comment was created in""" + + is_answer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isAnswer") + """Has this comment been chosen as the answer of its discussion?""" + + replies = sgqlc.types.Field( + sgqlc.types.non_null(DiscussionCommentConnection), + graphql_name="replies", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The threaded replies to this comment. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + reply_to = sgqlc.types.Field("DiscussionComment", graphql_name="replyTo") + """The discussion comment this comment is a reply to""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The path for this discussion comment.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The URL for this discussion comment.""" + + viewer_can_mark_as_answer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanMarkAsAnswer") + """Can the current user mark this comment as an answer?""" + + viewer_can_unmark_as_answer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanUnmarkAsAnswer") + """Can the current user unmark this comment as an answer?""" + + +class DiscussionPoll(sgqlc.types.Type, Node): + """A poll for a discussion.""" + + __schema__ = github_schema + __field_names__ = ("discussion", "options", "question", "total_vote_count", "viewer_can_vote", "viewer_has_voted") + discussion = sgqlc.types.Field(Discussion, graphql_name="discussion") + """The discussion that this poll belongs to.""" + + options = sgqlc.types.Field( + DiscussionPollOptionConnection, + graphql_name="options", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg( + DiscussionPollOptionOrder, graphql_name="orderBy", default={"field": "AUTHORED_ORDER", "direction": "ASC"} + ), + ), + ) + ), + ) + """The options for this poll. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`DiscussionPollOptionOrder`): How to order the + options for the discussion poll. (default: `{field: + AUTHORED_ORDER, direction: ASC}`) + """ + + question = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="question") + """The question that is being asked by this poll.""" + + total_vote_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalVoteCount") + """The total number of votes that have been cast for this poll.""" + + viewer_can_vote = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanVote") + """Indicates if the viewer has permission to vote in this poll.""" + + viewer_has_voted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerHasVoted") + """Indicates if the viewer has voted for any option in this poll.""" + + +class DiscussionPollOption(sgqlc.types.Type, Node): + """An option for a discussion poll.""" + + __schema__ = github_schema + __field_names__ = ("option", "poll", "total_vote_count", "viewer_has_voted") + option = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="option") + """The text for this option.""" + + poll = sgqlc.types.Field(DiscussionPoll, graphql_name="poll") + """The discussion poll that this option belongs to.""" + + total_vote_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalVoteCount") + """The total number of votes that have been cast for this option.""" + + viewer_has_voted = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerHasVoted") + """Indicates if the viewer has voted for this option in the poll.""" + + +class DraftIssue(sgqlc.types.Type, Node): + """A draft issue within a project.""" + + __schema__ = github_schema + __field_names__ = ( + "assignees", + "body", + "body_html", + "body_text", + "created_at", + "creator", + "project", + "project_item", + "title", + "updated_at", + ) + assignees = sgqlc.types.Field( + sgqlc.types.non_null(UserConnection), + graphql_name="assignees", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users to assigned to this draft issue. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The body of the draft issue.""" + + body_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="bodyHTML") + """The body of the draft issue rendered to HTML.""" + + body_text = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="bodyText") + """The body of the draft issue rendered to text.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who created this draft issue.""" + + project = sgqlc.types.Field(sgqlc.types.non_null("ProjectNext"), graphql_name="project") + """The project (beta) that contains this draft issue.""" + + project_item = sgqlc.types.Field(sgqlc.types.non_null("ProjectNextItem"), graphql_name="projectItem") + """The project (beta) item that wraps this draft issue.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the draft issue""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class Enterprise(sgqlc.types.Type, Node): + """An account to manage multiple organizations with consolidated + policy and billing. + """ + + __schema__ = github_schema + __field_names__ = ( + "avatar_url", + "billing_info", + "created_at", + "database_id", + "description", + "description_html", + "location", + "members", + "name", + "organizations", + "owner_info", + "resource_path", + "slug", + "url", + "viewer_is_admin", + "website_url", + ) + avatar_url = sgqlc.types.Field( + sgqlc.types.non_null(URI), + graphql_name="avatarUrl", + args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=None)),)), + ) + """A URL pointing to the enterprise's public avatar. + + Arguments: + + * `size` (`Int`): The size of the resulting square image. + """ + + billing_info = sgqlc.types.Field(EnterpriseBillingInfo, graphql_name="billingInfo") + """Enterprise billing information visible to enterprise billing + managers. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The description of the enterprise.""" + + description_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="descriptionHTML") + """The description of the enterprise as HTML.""" + + location = sgqlc.types.Field(String, graphql_name="location") + """The location of the enterprise.""" + + members = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseMemberConnection), + graphql_name="members", + args=sgqlc.types.ArgDict( + ( + ( + "organization_logins", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="organizationLogins", default=None), + ), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ( + "order_by", + sgqlc.types.Arg(EnterpriseMemberOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"}), + ), + ("role", sgqlc.types.Arg(EnterpriseUserAccountMembershipRole, graphql_name="role", default=None)), + ("deployment", sgqlc.types.Arg(EnterpriseUserDeployment, graphql_name="deployment", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users who are members of this enterprise. + + Arguments: + + * `organization_logins` (`[String!]`): Only return members within + the organizations with these logins + * `query` (`String`): The search string to look for. + * `order_by` (`EnterpriseMemberOrder`): Ordering options for + members returned from the connection. (default: `{field: LOGIN, + direction: ASC}`) + * `role` (`EnterpriseUserAccountMembershipRole`): The role of the + user in the enterprise organization or server. + * `deployment` (`EnterpriseUserDeployment`): Only return members + within the selected GitHub Enterprise deployment + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the enterprise.""" + + organizations = sgqlc.types.Field( + sgqlc.types.non_null(OrganizationConnection), + graphql_name="organizations", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("viewer_organization_role", sgqlc.types.Arg(RoleInOrganization, graphql_name="viewerOrganizationRole", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of organizations that belong to this enterprise. + + Arguments: + + * `query` (`String`): The search string to look for. + * `viewer_organization_role` (`RoleInOrganization`): The viewer's + role in an organization. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations returned from the connection. (default: `{field: + LOGIN, direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + owner_info = sgqlc.types.Field(EnterpriseOwnerInfo, graphql_name="ownerInfo") + """Enterprise information only visible to enterprise owners.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this enterprise.""" + + slug = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="slug") + """The URL-friendly identifier for the enterprise.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this enterprise.""" + + viewer_is_admin = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerIsAdmin") + """Is the current viewer an admin of this enterprise?""" + + website_url = sgqlc.types.Field(URI, graphql_name="websiteUrl") + """The URL of the enterprise website.""" + + +class EnterpriseAdministratorInvitation(sgqlc.types.Type, Node): + """An invitation for a user to become an owner or billing manager of + an enterprise. + """ + + __schema__ = github_schema + __field_names__ = ("created_at", "email", "enterprise", "invitee", "inviter", "role") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + email = sgqlc.types.Field(String, graphql_name="email") + """The email of the person who was invited to the enterprise.""" + + enterprise = sgqlc.types.Field(sgqlc.types.non_null(Enterprise), graphql_name="enterprise") + """The enterprise the invitation is for.""" + + invitee = sgqlc.types.Field("User", graphql_name="invitee") + """The user who was invited to the enterprise.""" + + inviter = sgqlc.types.Field("User", graphql_name="inviter") + """The user who created the invitation.""" + + role = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseAdministratorRole), graphql_name="role") + """The invitee's pending role in the enterprise (owner or + billing_manager). + """ + + +class EnterpriseIdentityProvider(sgqlc.types.Type, Node): + """An identity provider configured to provision identities for an + enterprise. + """ + + __schema__ = github_schema + __field_names__ = ( + "digest_method", + "enterprise", + "external_identities", + "idp_certificate", + "issuer", + "recovery_codes", + "signature_method", + "sso_url", + ) + digest_method = sgqlc.types.Field(SamlDigestAlgorithm, graphql_name="digestMethod") + """The digest algorithm used to sign SAML requests for the identity + provider. + """ + + enterprise = sgqlc.types.Field(Enterprise, graphql_name="enterprise") + """The enterprise this identity provider belongs to.""" + + external_identities = sgqlc.types.Field( + sgqlc.types.non_null(ExternalIdentityConnection), + graphql_name="externalIdentities", + args=sgqlc.types.ArgDict( + ( + ("members_only", sgqlc.types.Arg(Boolean, graphql_name="membersOnly", default=None)), + ("login", sgqlc.types.Arg(String, graphql_name="login", default=None)), + ("user_name", sgqlc.types.Arg(String, graphql_name="userName", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """ExternalIdentities provisioned by this identity provider. + + Arguments: + + * `members_only` (`Boolean`): Filter to external identities with + valid org membership only + * `login` (`String`): Filter to external identities with the users + login + * `user_name` (`String`): Filter to external identities with the + users userName/NameID attribute + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + idp_certificate = sgqlc.types.Field(X509Certificate, graphql_name="idpCertificate") + """The x509 certificate used by the identity provider to sign + assertions and responses. + """ + + issuer = sgqlc.types.Field(String, graphql_name="issuer") + """The Issuer Entity ID for the SAML identity provider.""" + + recovery_codes = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="recoveryCodes") + """Recovery codes that can be used by admins to access the enterprise + if the identity provider is unavailable. + """ + + signature_method = sgqlc.types.Field(SamlSignatureAlgorithm, graphql_name="signatureMethod") + """The signature algorithm used to sign SAML requests for the + identity provider. + """ + + sso_url = sgqlc.types.Field(URI, graphql_name="ssoUrl") + """The URL endpoint for the identity provider's SAML SSO.""" + + +class EnterpriseRepositoryInfo(sgqlc.types.Type, Node): + """A subset of repository information queryable from an enterprise.""" + + __schema__ = github_schema + __field_names__ = ("is_private", "name", "name_with_owner") + is_private = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPrivate") + """Identifies if the repository is private or internal.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The repository's name.""" + + name_with_owner = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="nameWithOwner") + """The repository's name with owner.""" + + +class EnterpriseServerInstallation(sgqlc.types.Type, Node): + """An Enterprise Server installation.""" + + __schema__ = github_schema + __field_names__ = ("created_at", "customer_name", "host_name", "is_connected", "updated_at", "user_accounts", "user_accounts_uploads") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + customer_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="customerName") + """The customer name to which the Enterprise Server installation + belongs. + """ + + host_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="hostName") + """The host name of the Enterprise Server installation.""" + + is_connected = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isConnected") + """Whether or not the installation is connected to an Enterprise + Server installation via GitHub Connect. + """ + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + user_accounts = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseServerUserAccountConnection), + graphql_name="userAccounts", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg( + EnterpriseServerUserAccountOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"} + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """User accounts on this Enterprise Server installation. + + Arguments: + + * `order_by` (`EnterpriseServerUserAccountOrder`): Ordering + options for Enterprise Server user accounts returned from the + connection. (default: `{field: LOGIN, direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + user_accounts_uploads = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseServerUserAccountsUploadConnection), + graphql_name="userAccountsUploads", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg( + EnterpriseServerUserAccountsUploadOrder, + graphql_name="orderBy", + default={"field": "CREATED_AT", "direction": "DESC"}, + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """User accounts uploads for the Enterprise Server installation. + + Arguments: + + * `order_by` (`EnterpriseServerUserAccountsUploadOrder`): Ordering + options for Enterprise Server user accounts uploads returned + from the connection. (default: `{field: CREATED_AT, direction: + DESC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class EnterpriseServerUserAccount(sgqlc.types.Type, Node): + """A user account on an Enterprise Server installation.""" + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "emails", + "enterprise_server_installation", + "is_site_admin", + "login", + "profile_name", + "remote_created_at", + "remote_user_id", + "updated_at", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + emails = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseServerUserAccountEmailConnection), + graphql_name="emails", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg( + EnterpriseServerUserAccountEmailOrder, graphql_name="orderBy", default={"field": "EMAIL", "direction": "ASC"} + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """User emails belonging to this user account. + + Arguments: + + * `order_by` (`EnterpriseServerUserAccountEmailOrder`): Ordering + options for Enterprise Server user account emails returned from + the connection. (default: `{field: EMAIL, direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + enterprise_server_installation = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseServerInstallation), graphql_name="enterpriseServerInstallation" + ) + """The Enterprise Server installation on which this user account + exists. + """ + + is_site_admin = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSiteAdmin") + """Whether the user account is a site administrator on the Enterprise + Server installation. + """ + + login = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="login") + """The login of the user account on the Enterprise Server + installation. + """ + + profile_name = sgqlc.types.Field(String, graphql_name="profileName") + """The profile name of the user account on the Enterprise Server + installation. + """ + + remote_created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="remoteCreatedAt") + """The date and time when the user account was created on the + Enterprise Server installation. + """ + + remote_user_id = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="remoteUserId") + """The ID of the user account on the Enterprise Server installation.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class EnterpriseServerUserAccountEmail(sgqlc.types.Type, Node): + """An email belonging to a user account on an Enterprise Server + installation. + """ + + __schema__ = github_schema + __field_names__ = ("created_at", "email", "is_primary", "updated_at", "user_account") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + email = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="email") + """The email address.""" + + is_primary = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPrimary") + """Indicates whether this is the primary email of the associated user + account. + """ + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + user_account = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseServerUserAccount), graphql_name="userAccount") + """The user account to which the email belongs.""" + + +class EnterpriseServerUserAccountsUpload(sgqlc.types.Type, Node): + """A user accounts upload from an Enterprise Server installation.""" + + __schema__ = github_schema + __field_names__ = ("created_at", "enterprise", "enterprise_server_installation", "name", "sync_state", "updated_at") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + enterprise = sgqlc.types.Field(sgqlc.types.non_null(Enterprise), graphql_name="enterprise") + """The enterprise to which this upload belongs.""" + + enterprise_server_installation = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseServerInstallation), graphql_name="enterpriseServerInstallation" + ) + """The Enterprise Server installation for which this upload was + generated. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the file uploaded.""" + + sync_state = sgqlc.types.Field(sgqlc.types.non_null(EnterpriseServerUserAccountsUploadSyncState), graphql_name="syncState") + """The synchronization state of the upload""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class EnterpriseUserAccount(sgqlc.types.Type, Actor, Node): + """An account for a user who is an admin of an enterprise or a member + of an enterprise through one or more organizations. + """ + + __schema__ = github_schema + __field_names__ = ("created_at", "enterprise", "name", "organizations", "updated_at", "user") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + enterprise = sgqlc.types.Field(sgqlc.types.non_null(Enterprise), graphql_name="enterprise") + """The enterprise in which this user account exists.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the enterprise user account""" + + organizations = sgqlc.types.Field( + sgqlc.types.non_null(EnterpriseOrganizationMembershipConnection), + graphql_name="organizations", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("order_by", sgqlc.types.Arg(OrganizationOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"})), + ("role", sgqlc.types.Arg(EnterpriseUserAccountMembershipRole, graphql_name="role", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of enterprise organizations this user is a member of. + + Arguments: + + * `query` (`String`): The search string to look for. + * `order_by` (`OrganizationOrder`): Ordering options for + organizations returned from the connection. (default: `{field: + LOGIN, direction: ASC}`) + * `role` (`EnterpriseUserAccountMembershipRole`): The role of the + user in the enterprise organization. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + user = sgqlc.types.Field("User", graphql_name="user") + """The user within the enterprise.""" + + +class Environment(sgqlc.types.Type, Node): + """An environment.""" + + __schema__ = github_schema + __field_names__ = ("database_id", "name", "protection_rules") + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the environment""" + + protection_rules = sgqlc.types.Field( + sgqlc.types.non_null(DeploymentProtectionRuleConnection), + graphql_name="protectionRules", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The protection rules defined for this environment + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class ExternalIdentity(sgqlc.types.Type, Node): + """An external identity provisioned by SAML SSO or SCIM.""" + + __schema__ = github_schema + __field_names__ = ("guid", "organization_invitation", "saml_identity", "scim_identity", "user") + guid = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="guid") + """The GUID for this identity""" + + organization_invitation = sgqlc.types.Field("OrganizationInvitation", graphql_name="organizationInvitation") + """Organization invitation for this SCIM-provisioned external + identity + """ + + saml_identity = sgqlc.types.Field(ExternalIdentitySamlAttributes, graphql_name="samlIdentity") + """SAML Identity attributes""" + + scim_identity = sgqlc.types.Field(ExternalIdentityScimAttributes, graphql_name="scimIdentity") + """SCIM Identity attributes""" + + user = sgqlc.types.Field("User", graphql_name="user") + """User linked to this external identity. Will be NULL if this + identity has not been claimed by an organization member. + """ + + +class GenericHovercardContext(sgqlc.types.Type, HovercardContext): + """A generic hovercard context with a message and icon""" + + __schema__ = github_schema + __field_names__ = () + + +class Gist(sgqlc.types.Type, Node, Starrable, UniformResourceLocatable): + """A Gist.""" + + __schema__ = github_schema + __field_names__ = ( + "comments", + "created_at", + "description", + "files", + "forks", + "is_fork", + "is_public", + "name", + "owner", + "pushed_at", + "updated_at", + ) + comments = sgqlc.types.Field( + sgqlc.types.non_null(GistCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of comments associated with the gist + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The gist description.""" + + files = sgqlc.types.Field( + sgqlc.types.list_of(GistFile), + graphql_name="files", + args=sgqlc.types.ArgDict( + ( + ("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=10)), + ("oid", sgqlc.types.Arg(GitObjectID, graphql_name="oid", default=None)), + ) + ), + ) + """The files in this gist. + + Arguments: + + * `limit` (`Int`): The maximum number of files to return. + (default: `10`) + * `oid` (`GitObjectID`): The oid of the files to return + """ + + forks = sgqlc.types.Field( + sgqlc.types.non_null(GistConnection), + graphql_name="forks", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(GistOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """A list of forks associated with the gist + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`GistOrder`): Ordering options for gists returned + from the connection + """ + + is_fork = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isFork") + """Identifies if the gist is a fork.""" + + is_public = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPublic") + """Whether the gist is public or not.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The gist name.""" + + owner = sgqlc.types.Field(RepositoryOwner, graphql_name="owner") + """The gist owner.""" + + pushed_at = sgqlc.types.Field(DateTime, graphql_name="pushedAt") + """Identifies when the gist was last pushed to.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class GistComment(sgqlc.types.Type, Node, Comment, Deletable, Minimizable, Updatable, UpdatableComment): + """Represents a comment on an Gist.""" + + __schema__ = github_schema + __field_names__ = ("database_id", "gist") + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + gist = sgqlc.types.Field(sgqlc.types.non_null(Gist), graphql_name="gist") + """The associated gist.""" + + +class GpgSignature(sgqlc.types.Type, GitSignature): + """Represents a GPG signature on a Commit or Tag.""" + + __schema__ = github_schema + __field_names__ = ("key_id",) + key_id = sgqlc.types.Field(String, graphql_name="keyId") + """Hex-encoded ID of the key that signed this object.""" + + +class HeadRefDeletedEvent(sgqlc.types.Type, Node): + """Represents a 'head_ref_deleted' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "head_ref", "head_ref_name", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + head_ref = sgqlc.types.Field("Ref", graphql_name="headRef") + """Identifies the Ref associated with the `head_ref_deleted` event.""" + + head_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="headRefName") + """Identifies the name of the Ref associated with the + `head_ref_deleted` event. + """ + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class HeadRefForcePushedEvent(sgqlc.types.Type, Node): + """Represents a 'head_ref_force_pushed' event on a given pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "after_commit", "before_commit", "created_at", "pull_request", "ref") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + after_commit = sgqlc.types.Field(Commit, graphql_name="afterCommit") + """Identifies the after commit SHA for the 'head_ref_force_pushed' + event. + """ + + before_commit = sgqlc.types.Field(Commit, graphql_name="beforeCommit") + """Identifies the before commit SHA for the 'head_ref_force_pushed' + event. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + ref = sgqlc.types.Field("Ref", graphql_name="ref") + """Identifies the fully qualified ref name for the + 'head_ref_force_pushed' event. + """ + + +class HeadRefRestoredEvent(sgqlc.types.Type, Node): + """Represents a 'head_ref_restored' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class IpAllowListEntry(sgqlc.types.Type, Node): + """An IP address or range of addresses that is allowed to access an + owner's resources. + """ + + __schema__ = github_schema + __field_names__ = ("allow_list_value", "created_at", "is_active", "name", "owner", "updated_at") + allow_list_value = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="allowListValue") + """A single IP address or range of IP addresses in CIDR notation.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + is_active = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isActive") + """Whether the entry is currently active.""" + + name = sgqlc.types.Field(String, graphql_name="name") + """The name of the IP allow list entry.""" + + owner = sgqlc.types.Field(sgqlc.types.non_null("IpAllowListOwner"), graphql_name="owner") + """The owner of the IP allow list entry.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class Issue( + sgqlc.types.Type, + Node, + Assignable, + Closable, + Comment, + Updatable, + UpdatableComment, + Labelable, + Lockable, + Reactable, + RepositoryNode, + Subscribable, + UniformResourceLocatable, + ProjectNextOwner, +): + """An Issue is a place to discuss ideas, enhancements, tasks, and + bugs for a project. + """ + + __schema__ = github_schema + __field_names__ = ( + "body_resource_path", + "body_url", + "comments", + "hovercard", + "is_pinned", + "is_read_by_viewer", + "milestone", + "number", + "participants", + "project_cards", + "project_next_items", + "state", + "state_reason", + "timeline_items", + "title", + "title_html", + "tracked_in_issues", + "tracked_issues", + "tracked_issues_count", + ) + body_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="bodyResourcePath") + """The http path for this issue body""" + + body_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="bodyUrl") + """The http URL for this issue body""" + + comments = sgqlc.types.Field( + sgqlc.types.non_null(IssueCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(IssueCommentOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of comments associated with the Issue. + + Arguments: + + * `order_by` (`IssueCommentOrder`): Ordering options for issue + comments returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + hovercard = sgqlc.types.Field( + sgqlc.types.non_null(Hovercard), + graphql_name="hovercard", + args=sgqlc.types.ArgDict( + (("include_notification_contexts", sgqlc.types.Arg(Boolean, graphql_name="includeNotificationContexts", default=True)),) + ), + ) + """The hovercard information for this issue + + Arguments: + + * `include_notification_contexts` (`Boolean`): Whether or not to + include notification contexts (default: `true`) + """ + + is_pinned = sgqlc.types.Field(Boolean, graphql_name="isPinned") + """Indicates whether or not this issue is currently pinned to the + repository issues list + """ + + is_read_by_viewer = sgqlc.types.Field(Boolean, graphql_name="isReadByViewer") + """Is this issue read by the viewer""" + + milestone = sgqlc.types.Field("Milestone", graphql_name="milestone") + """Identifies the milestone associated with the issue.""" + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """Identifies the issue number.""" + + participants = sgqlc.types.Field( + sgqlc.types.non_null(UserConnection), + graphql_name="participants", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of Users that are participating in the Issue conversation. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + project_cards = sgqlc.types.Field( + sgqlc.types.non_null(ProjectCardConnection), + graphql_name="projectCards", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "archived_states", + sgqlc.types.Arg( + sgqlc.types.list_of(ProjectCardArchivedState), graphql_name="archivedStates", default=("ARCHIVED", "NOT_ARCHIVED") + ), + ), + ) + ), + ) + """List of project cards associated with this issue. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `archived_states` (`[ProjectCardArchivedState]`): A list of + archived states to filter the cards by (default: `[ARCHIVED, + NOT_ARCHIVED]`) + """ + + project_next_items = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextItemConnection), + graphql_name="projectNextItems", + args=sgqlc.types.ArgDict( + ( + ("include_archived", sgqlc.types.Arg(Boolean, graphql_name="includeArchived", default=True)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of project (beta) items associated with this issue. + + Arguments: + + * `include_archived` (`Boolean`): Include archived items. + (default: `true`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + state = sgqlc.types.Field(sgqlc.types.non_null(IssueState), graphql_name="state") + """Identifies the state of the issue.""" + + state_reason = sgqlc.types.Field(IssueStateReason, graphql_name="stateReason") + """Identifies the reason for the issue state.""" + + timeline_items = sgqlc.types.Field( + sgqlc.types.non_null(IssueTimelineItemsConnection), + graphql_name="timelineItems", + args=sgqlc.types.ArgDict( + ( + ("since", sgqlc.types.Arg(DateTime, graphql_name="since", default=None)), + ("skip", sgqlc.types.Arg(Int, graphql_name="skip", default=None)), + ( + "item_types", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(IssueTimelineItemsItemType)), graphql_name="itemTypes", default=None + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of events, comments, commits, etc. associated with the + issue. + + Arguments: + + * `since` (`DateTime`): Filter timeline items by a `since` + timestamp. + * `skip` (`Int`): Skips the first _n_ elements in the list. + * `item_types` (`[IssueTimelineItemsItemType!]`): Filter timeline + items by type. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """Identifies the issue title.""" + + title_html = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="titleHTML") + """Identifies the issue title rendered to HTML.""" + + tracked_in_issues = sgqlc.types.Field( + sgqlc.types.non_null(IssueConnection), + graphql_name="trackedInIssues", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of issues that track this issue + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + tracked_issues = sgqlc.types.Field( + sgqlc.types.non_null(IssueConnection), + graphql_name="trackedIssues", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of issues tracked inside the current issue + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + tracked_issues_count = sgqlc.types.Field( + sgqlc.types.non_null(Int), + graphql_name="trackedIssuesCount", + args=sgqlc.types.ArgDict( + (("states", sgqlc.types.Arg(sgqlc.types.list_of(TrackedIssueStates), graphql_name="states", default=None)),) + ), + ) + """The number of tracked issues for this issue + + Arguments: + + * `states` (`[TrackedIssueStates]`): Limit the count to tracked + issues with the specified states. + """ + + +class IssueComment(sgqlc.types.Type, Node, Comment, Deletable, Minimizable, Updatable, UpdatableComment, Reactable, RepositoryNode): + """Represents a comment on an Issue.""" + + __schema__ = github_schema + __field_names__ = ("issue", "pull_request", "resource_path", "url") + issue = sgqlc.types.Field(sgqlc.types.non_null(Issue), graphql_name="issue") + """Identifies the issue associated with the comment.""" + + pull_request = sgqlc.types.Field("PullRequest", graphql_name="pullRequest") + """Returns the pull request associated with the comment, if this + comment was made on a pull request. + """ + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this issue comment""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this issue comment""" + + +class JoinedGitHubContribution(sgqlc.types.Type, Contribution): + """Represents a user signing up for a GitHub account.""" + + __schema__ = github_schema + __field_names__ = () + + +class Label(sgqlc.types.Type, Node): + """A label for categorizing Issues, Pull Requests, Milestones, or + Discussions with a given Repository. + """ + + __schema__ = github_schema + __field_names__ = ( + "color", + "created_at", + "description", + "is_default", + "issues", + "name", + "pull_requests", + "repository", + "resource_path", + "updated_at", + "url", + ) + color = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="color") + """Identifies the label color.""" + + created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt") + """Identifies the date and time when the label was created.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """A brief description of this label.""" + + is_default = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDefault") + """Indicates whether or not this is a default label.""" + + issues = sgqlc.types.Field( + sgqlc.types.non_null(IssueConnection), + graphql_name="issues", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("states", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(IssueState)), graphql_name="states", default=None)), + ("filter_by", sgqlc.types.Arg(IssueFilters, graphql_name="filterBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of issues associated with this label. + + Arguments: + + * `order_by` (`IssueOrder`): Ordering options for issues returned + from the connection. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `states` (`[IssueState!]`): A list of states to filter the + issues by. + * `filter_by` (`IssueFilters`): Filtering options for issues + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Identifies the label name.""" + + pull_requests = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestConnection), + graphql_name="pullRequests", + args=sgqlc.types.ArgDict( + ( + ( + "states", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PullRequestState)), graphql_name="states", default=None), + ), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("head_ref_name", sgqlc.types.Arg(String, graphql_name="headRefName", default=None)), + ("base_ref_name", sgqlc.types.Arg(String, graphql_name="baseRefName", default=None)), + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pull requests associated with this label. + + Arguments: + + * `states` (`[PullRequestState!]`): A list of states to filter the + pull requests by. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `head_ref_name` (`String`): The head ref name to filter the pull + requests by. + * `base_ref_name` (`String`): The base ref name to filter the pull + requests by. + * `order_by` (`IssueOrder`): Ordering options for pull requests + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository associated with this label.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this label.""" + + updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt") + """Identifies the date and time when the label was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this label.""" + + +class LabeledEvent(sgqlc.types.Type, Node): + """Represents a 'labeled' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "label", "labelable") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + label = sgqlc.types.Field(sgqlc.types.non_null(Label), graphql_name="label") + """Identifies the label associated with the 'labeled' event.""" + + labelable = sgqlc.types.Field(sgqlc.types.non_null(Labelable), graphql_name="labelable") + """Identifies the `Labelable` associated with the event.""" + + +class Language(sgqlc.types.Type, Node): + """Represents a given language found in repositories.""" + + __schema__ = github_schema + __field_names__ = ("color", "name") + color = sgqlc.types.Field(String, graphql_name="color") + """The color defined for the current language.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the current language.""" + + +class License(sgqlc.types.Type, Node): + """A repository's open source license""" + + __schema__ = github_schema + __field_names__ = ( + "body", + "conditions", + "description", + "featured", + "hidden", + "implementation", + "key", + "limitations", + "name", + "nickname", + "permissions", + "pseudo_license", + "spdx_id", + "url", + ) + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The full text of the license""" + + conditions = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(LicenseRule)), graphql_name="conditions") + """The conditions set by the license""" + + description = sgqlc.types.Field(String, graphql_name="description") + """A human-readable description of the license""" + + featured = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="featured") + """Whether the license should be featured""" + + hidden = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hidden") + """Whether the license should be displayed in license pickers""" + + implementation = sgqlc.types.Field(String, graphql_name="implementation") + """Instructions on how to implement the license""" + + key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key") + """The lowercased SPDX ID of the license""" + + limitations = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(LicenseRule)), graphql_name="limitations") + """The limitations set by the license""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The license full name specified by """ + + nickname = sgqlc.types.Field(String, graphql_name="nickname") + """Customary short name if applicable (e.g, GPLv3)""" + + permissions = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(LicenseRule)), graphql_name="permissions") + """The permissions set by the license""" + + pseudo_license = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="pseudoLicense") + """Whether the license is a pseudo-license placeholder (e.g., other, + no-license) + """ + + spdx_id = sgqlc.types.Field(String, graphql_name="spdxId") + """Short identifier specified by """ + + url = sgqlc.types.Field(URI, graphql_name="url") + """URL to the license on """ + + +class LockedEvent(sgqlc.types.Type, Node): + """Represents a 'locked' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "lock_reason", "lockable") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + lock_reason = sgqlc.types.Field(LockReason, graphql_name="lockReason") + """Reason that the conversation was locked (optional).""" + + lockable = sgqlc.types.Field(sgqlc.types.non_null(Lockable), graphql_name="lockable") + """Object that was locked.""" + + +class Mannequin(sgqlc.types.Type, Node, Actor, UniformResourceLocatable): + """A placeholder user for attribution of imported data on GitHub.""" + + __schema__ = github_schema + __field_names__ = ("claimant", "created_at", "database_id", "email", "updated_at") + claimant = sgqlc.types.Field("User", graphql_name="claimant") + """The user that has claimed the data attributed to this mannequin.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + email = sgqlc.types.Field(String, graphql_name="email") + """The mannequin's email on the source instance.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class MarkedAsDuplicateEvent(sgqlc.types.Type, Node): + """Represents a 'marked_as_duplicate' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "canonical", "created_at", "duplicate", "is_cross_repository") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + canonical = sgqlc.types.Field("IssueOrPullRequest", graphql_name="canonical") + """The authoritative issue or pull request which has been duplicated + by another. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + duplicate = sgqlc.types.Field("IssueOrPullRequest", graphql_name="duplicate") + """The issue or pull request which has been marked as a duplicate of + another. + """ + + is_cross_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCrossRepository") + """Canonical and duplicate belong to different repositories.""" + + +class MarketplaceCategory(sgqlc.types.Type, Node): + """A public description of a Marketplace category.""" + + __schema__ = github_schema + __field_names__ = ( + "description", + "how_it_works", + "name", + "primary_listing_count", + "resource_path", + "secondary_listing_count", + "slug", + "url", + ) + description = sgqlc.types.Field(String, graphql_name="description") + """The category's description.""" + + how_it_works = sgqlc.types.Field(String, graphql_name="howItWorks") + """The technical description of how apps listed in this category work + with GitHub. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The category's name.""" + + primary_listing_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="primaryListingCount") + """How many Marketplace listings have this as their primary category.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this Marketplace category.""" + + secondary_listing_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="secondaryListingCount") + """How many Marketplace listings have this as their secondary + category. + """ + + slug = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="slug") + """The short name of the category used in its URL.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this Marketplace category.""" + + +class MarketplaceListing(sgqlc.types.Type, Node): + """A listing in the GitHub integration marketplace.""" + + __schema__ = github_schema + __field_names__ = ( + "app", + "company_url", + "configuration_resource_path", + "configuration_url", + "documentation_url", + "extended_description", + "extended_description_html", + "full_description", + "full_description_html", + "has_published_free_trial_plans", + "has_terms_of_service", + "has_verified_owner", + "how_it_works", + "how_it_works_html", + "installation_url", + "installed_for_viewer", + "is_archived", + "is_draft", + "is_paid", + "is_public", + "is_rejected", + "is_unverified", + "is_unverified_pending", + "is_verification_pending_from_draft", + "is_verification_pending_from_unverified", + "is_verified", + "logo_background_color", + "logo_url", + "name", + "normalized_short_description", + "pricing_url", + "primary_category", + "privacy_policy_url", + "resource_path", + "screenshot_urls", + "secondary_category", + "short_description", + "slug", + "status_url", + "support_email", + "support_url", + "terms_of_service_url", + "url", + "viewer_can_add_plans", + "viewer_can_approve", + "viewer_can_delist", + "viewer_can_edit", + "viewer_can_edit_categories", + "viewer_can_edit_plans", + "viewer_can_redraft", + "viewer_can_reject", + "viewer_can_request_approval", + "viewer_has_purchased", + "viewer_has_purchased_for_all_organizations", + "viewer_is_listing_admin", + ) + app = sgqlc.types.Field(App, graphql_name="app") + """The GitHub App this listing represents.""" + + company_url = sgqlc.types.Field(URI, graphql_name="companyUrl") + """URL to the listing owner's company site.""" + + configuration_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="configurationResourcePath") + """The HTTP path for configuring access to the listing's integration + or OAuth app + """ + + configuration_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="configurationUrl") + """The HTTP URL for configuring access to the listing's integration + or OAuth app + """ + + documentation_url = sgqlc.types.Field(URI, graphql_name="documentationUrl") + """URL to the listing's documentation.""" + + extended_description = sgqlc.types.Field(String, graphql_name="extendedDescription") + """The listing's detailed description.""" + + extended_description_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="extendedDescriptionHTML") + """The listing's detailed description rendered to HTML.""" + + full_description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fullDescription") + """The listing's introductory description.""" + + full_description_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="fullDescriptionHTML") + """The listing's introductory description rendered to HTML.""" + + has_published_free_trial_plans = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasPublishedFreeTrialPlans") + """Does this listing have any plans with a free trial?""" + + has_terms_of_service = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasTermsOfService") + """Does this listing have a terms of service link?""" + + has_verified_owner = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasVerifiedOwner") + """Whether the creator of the app is a verified org""" + + how_it_works = sgqlc.types.Field(String, graphql_name="howItWorks") + """A technical description of how this app works with GitHub.""" + + how_it_works_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="howItWorksHTML") + """The listing's technical description rendered to HTML.""" + + installation_url = sgqlc.types.Field(URI, graphql_name="installationUrl") + """URL to install the product to the viewer's account or + organization. + """ + + installed_for_viewer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="installedForViewer") + """Whether this listing's app has been installed for the current + viewer + """ + + is_archived = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isArchived") + """Whether this listing has been removed from the Marketplace.""" + + is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft") + """Whether this listing is still an editable draft that has not been + submitted for review and is not publicly visible in the + Marketplace. + """ + + is_paid = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPaid") + """Whether the product this listing represents is available as part + of a paid plan. + """ + + is_public = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPublic") + """Whether this listing has been approved for display in the + Marketplace. + """ + + is_rejected = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isRejected") + """Whether this listing has been rejected by GitHub for display in + the Marketplace. + """ + + is_unverified = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isUnverified") + """Whether this listing has been approved for unverified display in + the Marketplace. + """ + + is_unverified_pending = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isUnverifiedPending") + """Whether this draft listing has been submitted for review for + approval to be unverified in the Marketplace. + """ + + is_verification_pending_from_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isVerificationPendingFromDraft") + """Whether this draft listing has been submitted for review from + GitHub for approval to be verified in the Marketplace. + """ + + is_verification_pending_from_unverified = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="isVerificationPendingFromUnverified" + ) + """Whether this unverified listing has been submitted for review from + GitHub for approval to be verified in the Marketplace. + """ + + is_verified = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isVerified") + """Whether this listing has been approved for verified display in the + Marketplace. + """ + + logo_background_color = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="logoBackgroundColor") + """The hex color code, without the leading '#', for the logo + background. + """ + + logo_url = sgqlc.types.Field( + URI, graphql_name="logoUrl", args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=400)),)) + ) + """URL for the listing's logo image. + + Arguments: + + * `size` (`Int`): The size in pixels of the resulting square + image. (default: `400`) + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The listing's full name.""" + + normalized_short_description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="normalizedShortDescription") + """The listing's very short description without a trailing period or + ampersands. + """ + + pricing_url = sgqlc.types.Field(URI, graphql_name="pricingUrl") + """URL to the listing's detailed pricing.""" + + primary_category = sgqlc.types.Field(sgqlc.types.non_null(MarketplaceCategory), graphql_name="primaryCategory") + """The category that best describes the listing.""" + + privacy_policy_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="privacyPolicyUrl") + """URL to the listing's privacy policy, may return an empty string + for listings that do not require a privacy policy URL. + """ + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for the Marketplace listing.""" + + screenshot_urls = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(String)), graphql_name="screenshotUrls") + """The URLs for the listing's screenshots.""" + + secondary_category = sgqlc.types.Field(MarketplaceCategory, graphql_name="secondaryCategory") + """An alternate category that describes the listing.""" + + short_description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="shortDescription") + """The listing's very short description.""" + + slug = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="slug") + """The short name of the listing used in its URL.""" + + status_url = sgqlc.types.Field(URI, graphql_name="statusUrl") + """URL to the listing's status page.""" + + support_email = sgqlc.types.Field(String, graphql_name="supportEmail") + """An email address for support for this listing's app.""" + + support_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="supportUrl") + """Either a URL or an email address for support for this listing's + app, may return an empty string for listings that do not require a + support URL. + """ + + terms_of_service_url = sgqlc.types.Field(URI, graphql_name="termsOfServiceUrl") + """URL to the listing's terms of service.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for the Marketplace listing.""" + + viewer_can_add_plans = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanAddPlans") + """Can the current viewer add plans for this Marketplace listing.""" + + viewer_can_approve = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanApprove") + """Can the current viewer approve this Marketplace listing.""" + + viewer_can_delist = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanDelist") + """Can the current viewer delist this Marketplace listing.""" + + viewer_can_edit = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanEdit") + """Can the current viewer edit this Marketplace listing.""" + + viewer_can_edit_categories = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanEditCategories") + """Can the current viewer edit the primary and secondary category of + this Marketplace listing. + """ + + viewer_can_edit_plans = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanEditPlans") + """Can the current viewer edit the plans for this Marketplace + listing. + """ + + viewer_can_redraft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanRedraft") + """Can the current viewer return this Marketplace listing to draft + state so it becomes editable again. + """ + + viewer_can_reject = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanReject") + """Can the current viewer reject this Marketplace listing by + returning it to an editable draft state or rejecting it entirely. + """ + + viewer_can_request_approval = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanRequestApproval") + """Can the current viewer request this listing be reviewed for + display in the Marketplace as verified. + """ + + viewer_has_purchased = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerHasPurchased") + """Indicates whether the current user has an active subscription to + this Marketplace listing. + """ + + viewer_has_purchased_for_all_organizations = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="viewerHasPurchasedForAllOrganizations" + ) + """Indicates if the current user has purchased a subscription to this + Marketplace listing for all of the organizations the user owns. + """ + + viewer_is_listing_admin = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerIsListingAdmin") + """Does the current viewer role allow them to administer this + Marketplace listing. + """ + + +class MembersCanDeleteReposClearAuditEntry(sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a members_can_delete_repos.clear event.""" + + __schema__ = github_schema + __field_names__ = () + + +class MembersCanDeleteReposDisableAuditEntry(sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a members_can_delete_repos.disable event.""" + + __schema__ = github_schema + __field_names__ = () + + +class MembersCanDeleteReposEnableAuditEntry(sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a members_can_delete_repos.enable event.""" + + __schema__ = github_schema + __field_names__ = () + + +class MentionedEvent(sgqlc.types.Type, Node): + """Represents a 'mentioned' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "database_id") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + +class MergedEvent(sgqlc.types.Type, Node, UniformResourceLocatable): + """Represents a 'merged' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "commit", "created_at", "merge_ref", "merge_ref_name", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """Identifies the commit associated with the `merge` event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + merge_ref = sgqlc.types.Field("Ref", graphql_name="mergeRef") + """Identifies the Ref associated with the `merge` event.""" + + merge_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="mergeRefName") + """Identifies the name of the Ref associated with the `merge` event.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null("PullRequest"), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class MigrationSource(sgqlc.types.Type, Node): + """An Octoshift migration source.""" + + __schema__ = github_schema + __field_names__ = ("name", "type", "url") + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The Octoshift migration source name.""" + + type = sgqlc.types.Field(sgqlc.types.non_null(MigrationSourceType), graphql_name="type") + """The Octoshift migration source type.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The Octoshift migration source URL.""" + + +class Milestone(sgqlc.types.Type, Node, Closable, UniformResourceLocatable): + """Represents a Milestone object on a given repository.""" + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "creator", + "description", + "due_on", + "issues", + "number", + "progress_percentage", + "pull_requests", + "repository", + "state", + "title", + "updated_at", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """Identifies the actor who created the milestone.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """Identifies the description of the milestone.""" + + due_on = sgqlc.types.Field(DateTime, graphql_name="dueOn") + """Identifies the due date of the milestone.""" + + issues = sgqlc.types.Field( + sgqlc.types.non_null(IssueConnection), + graphql_name="issues", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("states", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(IssueState)), graphql_name="states", default=None)), + ("filter_by", sgqlc.types.Arg(IssueFilters, graphql_name="filterBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of issues associated with the milestone. + + Arguments: + + * `order_by` (`IssueOrder`): Ordering options for issues returned + from the connection. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `states` (`[IssueState!]`): A list of states to filter the + issues by. + * `filter_by` (`IssueFilters`): Filtering options for issues + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """Identifies the number of the milestone.""" + + progress_percentage = sgqlc.types.Field(sgqlc.types.non_null(Float), graphql_name="progressPercentage") + """Identifies the percentage complete for the milestone""" + + pull_requests = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestConnection), + graphql_name="pullRequests", + args=sgqlc.types.ArgDict( + ( + ( + "states", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PullRequestState)), graphql_name="states", default=None), + ), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("head_ref_name", sgqlc.types.Arg(String, graphql_name="headRefName", default=None)), + ("base_ref_name", sgqlc.types.Arg(String, graphql_name="baseRefName", default=None)), + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pull requests associated with the milestone. + + Arguments: + + * `states` (`[PullRequestState!]`): A list of states to filter the + pull requests by. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `head_ref_name` (`String`): The head ref name to filter the pull + requests by. + * `base_ref_name` (`String`): The base ref name to filter the pull + requests by. + * `order_by` (`IssueOrder`): Ordering options for pull requests + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository associated with this milestone.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(MilestoneState), graphql_name="state") + """Identifies the state of the milestone.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """Identifies the title of the milestone.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class MilestonedEvent(sgqlc.types.Type, Node): + """Represents a 'milestoned' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "milestone_title", "subject") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + milestone_title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="milestoneTitle") + """Identifies the milestone title associated with the 'milestoned' + event. + """ + + subject = sgqlc.types.Field(sgqlc.types.non_null("MilestoneItem"), graphql_name="subject") + """Object referenced by event.""" + + +class MovedColumnsInProjectEvent(sgqlc.types.Type, Node): + """Represents a 'moved_columns_in_project' event on a given issue or + pull request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "database_id") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + +class OIDCProvider(sgqlc.types.Type, Node): + """An OIDC identity provider configured to provision identities for + an enterprise. + """ + + __schema__ = github_schema + __field_names__ = ("enterprise", "external_identities", "provider_type", "tenant_id") + enterprise = sgqlc.types.Field(Enterprise, graphql_name="enterprise") + """The enterprise this identity provider belongs to.""" + + external_identities = sgqlc.types.Field( + sgqlc.types.non_null(ExternalIdentityConnection), + graphql_name="externalIdentities", + args=sgqlc.types.ArgDict( + ( + ("members_only", sgqlc.types.Arg(Boolean, graphql_name="membersOnly", default=None)), + ("login", sgqlc.types.Arg(String, graphql_name="login", default=None)), + ("user_name", sgqlc.types.Arg(String, graphql_name="userName", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """ExternalIdentities provisioned by this identity provider. + + Arguments: + + * `members_only` (`Boolean`): Filter to external identities with + valid org membership only + * `login` (`String`): Filter to external identities with the users + login + * `user_name` (`String`): Filter to external identities with the + users userName/NameID attribute + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + provider_type = sgqlc.types.Field(sgqlc.types.non_null(OIDCProviderType), graphql_name="providerType") + """The OIDC identity provider type""" + + tenant_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tenantId") + """The id of the tenant this provider is attached to""" + + +class OauthApplicationCreateAuditEntry(sgqlc.types.Type, Node, AuditEntry, OauthApplicationAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a oauth_application.create event.""" + + __schema__ = github_schema + __field_names__ = ("application_url", "callback_url", "rate_limit", "state") + application_url = sgqlc.types.Field(URI, graphql_name="applicationUrl") + """The application URL of the OAuth Application.""" + + callback_url = sgqlc.types.Field(URI, graphql_name="callbackUrl") + """The callback URL of the OAuth Application.""" + + rate_limit = sgqlc.types.Field(Int, graphql_name="rateLimit") + """The rate limit of the OAuth Application.""" + + state = sgqlc.types.Field(OauthApplicationCreateAuditEntryState, graphql_name="state") + """The state of the OAuth Application.""" + + +class OrgAddBillingManagerAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.add_billing_manager""" + + __schema__ = github_schema + __field_names__ = ("invitation_email",) + invitation_email = sgqlc.types.Field(String, graphql_name="invitationEmail") + """The email address used to invite a billing manager for the + organization. + """ + + +class OrgAddMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.add_member""" + + __schema__ = github_schema + __field_names__ = ("permission",) + permission = sgqlc.types.Field(OrgAddMemberAuditEntryPermission, graphql_name="permission") + """The permission level of the member added to the organization.""" + + +class OrgBlockUserAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.block_user""" + + __schema__ = github_schema + __field_names__ = ("blocked_user", "blocked_user_name", "blocked_user_resource_path", "blocked_user_url") + blocked_user = sgqlc.types.Field("User", graphql_name="blockedUser") + """The blocked user.""" + + blocked_user_name = sgqlc.types.Field(String, graphql_name="blockedUserName") + """The username of the blocked user.""" + + blocked_user_resource_path = sgqlc.types.Field(URI, graphql_name="blockedUserResourcePath") + """The HTTP path for the blocked user.""" + + blocked_user_url = sgqlc.types.Field(URI, graphql_name="blockedUserUrl") + """The HTTP URL for the blocked user.""" + + +class OrgConfigDisableCollaboratorsOnlyAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.config.disable_collaborators_only event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgConfigEnableCollaboratorsOnlyAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.config.enable_collaborators_only event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgCreateAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.create event.""" + + __schema__ = github_schema + __field_names__ = ("billing_plan",) + billing_plan = sgqlc.types.Field(OrgCreateAuditEntryBillingPlan, graphql_name="billingPlan") + """The billing plan for the Organization.""" + + +class OrgDisableOauthAppRestrictionsAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.disable_oauth_app_restrictions event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgDisableSamlAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.disable_saml event.""" + + __schema__ = github_schema + __field_names__ = ("digest_method_url", "issuer_url", "signature_method_url", "single_sign_on_url") + digest_method_url = sgqlc.types.Field(URI, graphql_name="digestMethodUrl") + """The SAML provider's digest algorithm URL.""" + + issuer_url = sgqlc.types.Field(URI, graphql_name="issuerUrl") + """The SAML provider's issuer URL.""" + + signature_method_url = sgqlc.types.Field(URI, graphql_name="signatureMethodUrl") + """The SAML provider's signature algorithm URL.""" + + single_sign_on_url = sgqlc.types.Field(URI, graphql_name="singleSignOnUrl") + """The SAML provider's single sign-on URL.""" + + +class OrgDisableTwoFactorRequirementAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.disable_two_factor_requirement event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgEnableOauthAppRestrictionsAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.enable_oauth_app_restrictions event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgEnableSamlAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.enable_saml event.""" + + __schema__ = github_schema + __field_names__ = ("digest_method_url", "issuer_url", "signature_method_url", "single_sign_on_url") + digest_method_url = sgqlc.types.Field(URI, graphql_name="digestMethodUrl") + """The SAML provider's digest algorithm URL.""" + + issuer_url = sgqlc.types.Field(URI, graphql_name="issuerUrl") + """The SAML provider's issuer URL.""" + + signature_method_url = sgqlc.types.Field(URI, graphql_name="signatureMethodUrl") + """The SAML provider's signature algorithm URL.""" + + single_sign_on_url = sgqlc.types.Field(URI, graphql_name="singleSignOnUrl") + """The SAML provider's single sign-on URL.""" + + +class OrgEnableTwoFactorRequirementAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.enable_two_factor_requirement event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgInviteMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.invite_member event.""" + + __schema__ = github_schema + __field_names__ = ("email", "organization_invitation") + email = sgqlc.types.Field(String, graphql_name="email") + """The email address of the organization invitation.""" + + organization_invitation = sgqlc.types.Field("OrganizationInvitation", graphql_name="organizationInvitation") + """The organization invitation.""" + + +class OrgInviteToBusinessAuditEntry(sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a org.invite_to_business event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgOauthAppAccessApprovedAuditEntry(sgqlc.types.Type, Node, AuditEntry, OauthApplicationAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a org.oauth_app_access_approved event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgOauthAppAccessDeniedAuditEntry(sgqlc.types.Type, Node, AuditEntry, OauthApplicationAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a org.oauth_app_access_denied event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgOauthAppAccessRequestedAuditEntry(sgqlc.types.Type, Node, AuditEntry, OauthApplicationAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a org.oauth_app_access_requested event.""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgRemoveBillingManagerAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.remove_billing_manager event.""" + + __schema__ = github_schema + __field_names__ = ("reason",) + reason = sgqlc.types.Field(OrgRemoveBillingManagerAuditEntryReason, graphql_name="reason") + """The reason for the billing manager being removed.""" + + +class OrgRemoveMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.remove_member event.""" + + __schema__ = github_schema + __field_names__ = ("membership_types", "reason") + membership_types = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(OrgRemoveMemberAuditEntryMembershipType)), graphql_name="membershipTypes" + ) + """The types of membership the member has with the organization.""" + + reason = sgqlc.types.Field(OrgRemoveMemberAuditEntryReason, graphql_name="reason") + """The reason for the member being removed.""" + + +class OrgRemoveOutsideCollaboratorAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.remove_outside_collaborator event.""" + + __schema__ = github_schema + __field_names__ = ("membership_types", "reason") + membership_types = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(OrgRemoveOutsideCollaboratorAuditEntryMembershipType)), graphql_name="membershipTypes" + ) + """The types of membership the outside collaborator has with the + organization. + """ + + reason = sgqlc.types.Field(OrgRemoveOutsideCollaboratorAuditEntryReason, graphql_name="reason") + """The reason for the outside collaborator being removed from the + Organization. + """ + + +class OrgRestoreMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.restore_member event.""" + + __schema__ = github_schema + __field_names__ = ( + "restored_custom_email_routings_count", + "restored_issue_assignments_count", + "restored_memberships", + "restored_memberships_count", + "restored_repositories_count", + "restored_repository_stars_count", + "restored_repository_watches_count", + ) + restored_custom_email_routings_count = sgqlc.types.Field(Int, graphql_name="restoredCustomEmailRoutingsCount") + """The number of custom email routings for the restored member.""" + + restored_issue_assignments_count = sgqlc.types.Field(Int, graphql_name="restoredIssueAssignmentsCount") + """The number of issue assignments for the restored member.""" + + restored_memberships = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null("OrgRestoreMemberAuditEntryMembership")), graphql_name="restoredMemberships" + ) + """Restored organization membership objects.""" + + restored_memberships_count = sgqlc.types.Field(Int, graphql_name="restoredMembershipsCount") + """The number of restored memberships.""" + + restored_repositories_count = sgqlc.types.Field(Int, graphql_name="restoredRepositoriesCount") + """The number of repositories of the restored member.""" + + restored_repository_stars_count = sgqlc.types.Field(Int, graphql_name="restoredRepositoryStarsCount") + """The number of starred repositories for the restored member.""" + + restored_repository_watches_count = sgqlc.types.Field(Int, graphql_name="restoredRepositoryWatchesCount") + """The number of watched repositories for the restored member.""" + + +class OrgRestoreMemberMembershipOrganizationAuditEntryData(sgqlc.types.Type, OrganizationAuditEntryData): + """Metadata for an organization membership for org.restore_member + actions + """ + + __schema__ = github_schema + __field_names__ = () + + +class OrgRestoreMemberMembershipRepositoryAuditEntryData(sgqlc.types.Type, RepositoryAuditEntryData): + """Metadata for a repository membership for org.restore_member + actions + """ + + __schema__ = github_schema + __field_names__ = () + + +class OrgRestoreMemberMembershipTeamAuditEntryData(sgqlc.types.Type, TeamAuditEntryData): + """Metadata for a team membership for org.restore_member actions""" + + __schema__ = github_schema + __field_names__ = () + + +class OrgUnblockUserAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.unblock_user""" + + __schema__ = github_schema + __field_names__ = ("blocked_user", "blocked_user_name", "blocked_user_resource_path", "blocked_user_url") + blocked_user = sgqlc.types.Field("User", graphql_name="blockedUser") + """The user being unblocked by the organization.""" + + blocked_user_name = sgqlc.types.Field(String, graphql_name="blockedUserName") + """The username of the blocked user.""" + + blocked_user_resource_path = sgqlc.types.Field(URI, graphql_name="blockedUserResourcePath") + """The HTTP path for the blocked user.""" + + blocked_user_url = sgqlc.types.Field(URI, graphql_name="blockedUserUrl") + """The HTTP URL for the blocked user.""" + + +class OrgUpdateDefaultRepositoryPermissionAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.update_default_repository_permission""" + + __schema__ = github_schema + __field_names__ = ("permission", "permission_was") + permission = sgqlc.types.Field(OrgUpdateDefaultRepositoryPermissionAuditEntryPermission, graphql_name="permission") + """The new base repository permission level for the organization.""" + + permission_was = sgqlc.types.Field(OrgUpdateDefaultRepositoryPermissionAuditEntryPermission, graphql_name="permissionWas") + """The former base repository permission level for the organization.""" + + +class OrgUpdateMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a org.update_member event.""" + + __schema__ = github_schema + __field_names__ = ("permission", "permission_was") + permission = sgqlc.types.Field(OrgUpdateMemberAuditEntryPermission, graphql_name="permission") + """The new member permission level for the organization.""" + + permission_was = sgqlc.types.Field(OrgUpdateMemberAuditEntryPermission, graphql_name="permissionWas") + """The former member permission level for the organization.""" + + +class OrgUpdateMemberRepositoryCreationPermissionAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a + org.update_member_repository_creation_permission event. + """ + + __schema__ = github_schema + __field_names__ = ("can_create_repositories", "visibility") + can_create_repositories = sgqlc.types.Field(Boolean, graphql_name="canCreateRepositories") + """Can members create repositories in the organization.""" + + visibility = sgqlc.types.Field(OrgUpdateMemberRepositoryCreationPermissionAuditEntryVisibility, graphql_name="visibility") + """The permission for visibility level of repositories for this + organization. + """ + + +class OrgUpdateMemberRepositoryInvitationPermissionAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData): + """Audit log entry for a + org.update_member_repository_invitation_permission event. + """ + + __schema__ = github_schema + __field_names__ = ("can_invite_outside_collaborators_to_repositories",) + can_invite_outside_collaborators_to_repositories = sgqlc.types.Field( + Boolean, graphql_name="canInviteOutsideCollaboratorsToRepositories" + ) + """Can outside collaborators be invited to repositories in the + organization. + """ + + +class Organization( + sgqlc.types.Type, + Node, + Actor, + PackageOwner, + ProjectOwner, + ProjectNextOwner, + RepositoryDiscussionAuthor, + RepositoryDiscussionCommentAuthor, + RepositoryOwner, + UniformResourceLocatable, + MemberStatusable, + ProfileOwner, + Sponsorable, +): + """An account on GitHub, with one or more owners, that has + repositories, members and teams. + """ + + __schema__ = github_schema + __field_names__ = ( + "audit_log", + "created_at", + "database_id", + "description", + "description_html", + "domains", + "enterprise_owners", + "interaction_ability", + "ip_allow_list_enabled_setting", + "ip_allow_list_entries", + "ip_allow_list_for_installed_apps_enabled_setting", + "is_verified", + "members_can_fork_private_repositories", + "members_with_role", + "new_team_resource_path", + "new_team_url", + "notification_delivery_restriction_enabled_setting", + "organization_billing_email", + "pending_members", + "repository_migrations", + "requires_two_factor_authentication", + "saml_identity_provider", + "team", + "teams", + "teams_resource_path", + "teams_url", + "twitter_username", + "updated_at", + "viewer_can_administer", + "viewer_can_create_repositories", + "viewer_can_create_teams", + "viewer_is_amember", + "viewer_is_following", + ) + audit_log = sgqlc.types.Field( + sgqlc.types.non_null(OrganizationAuditEntryConnection), + graphql_name="auditLog", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("order_by", sgqlc.types.Arg(AuditLogOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "DESC"})), + ) + ), + ) + """Audit log entries of the organization + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `query` (`String`): The query string to filter audit entries + * `order_by` (`AuditLogOrder`): Ordering options for the returned + audit log entries. (default: `{field: CREATED_AT, direction: + DESC}`) + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The organization's public profile description.""" + + description_html = sgqlc.types.Field(String, graphql_name="descriptionHTML") + """The organization's public profile description rendered to HTML.""" + + domains = sgqlc.types.Field( + VerifiableDomainConnection, + graphql_name="domains", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("is_verified", sgqlc.types.Arg(Boolean, graphql_name="isVerified", default=None)), + ("is_approved", sgqlc.types.Arg(Boolean, graphql_name="isApproved", default=None)), + ( + "order_by", + sgqlc.types.Arg(VerifiableDomainOrder, graphql_name="orderBy", default={"field": "DOMAIN", "direction": "ASC"}), + ), + ) + ), + ) + """A list of domains owned by the organization. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `is_verified` (`Boolean`): Filter by if the domain is verified. + (default: `null`) + * `is_approved` (`Boolean`): Filter by if the domain is approved. + (default: `null`) + * `order_by` (`VerifiableDomainOrder`): Ordering options for + verifiable domains returned. (default: `{field: DOMAIN, + direction: ASC}`) + """ + + enterprise_owners = sgqlc.types.Field( + sgqlc.types.non_null(OrganizationEnterpriseOwnerConnection), + graphql_name="enterpriseOwners", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("organization_role", sgqlc.types.Arg(RoleInOrganization, graphql_name="organizationRole", default=None)), + ( + "order_by", + sgqlc.types.Arg(OrgEnterpriseOwnerOrder, graphql_name="orderBy", default={"field": "LOGIN", "direction": "ASC"}), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of owners of the organization's enterprise account. + + Arguments: + + * `query` (`String`): The search string to look for. + * `organization_role` (`RoleInOrganization`): The organization + role to filter by. + * `order_by` (`OrgEnterpriseOwnerOrder`): Ordering options for + enterprise owners returned from the connection. (default: + `{field: LOGIN, direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + interaction_ability = sgqlc.types.Field(RepositoryInteractionAbility, graphql_name="interactionAbility") + """The interaction ability settings for this organization.""" + + ip_allow_list_enabled_setting = sgqlc.types.Field( + sgqlc.types.non_null(IpAllowListEnabledSettingValue), graphql_name="ipAllowListEnabledSetting" + ) + """The setting value for whether the organization has an IP allow + list enabled. + """ + + ip_allow_list_entries = sgqlc.types.Field( + sgqlc.types.non_null(IpAllowListEntryConnection), + graphql_name="ipAllowListEntries", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg( + IpAllowListEntryOrder, graphql_name="orderBy", default={"field": "ALLOW_LIST_VALUE", "direction": "ASC"} + ), + ), + ) + ), + ) + """The IP addresses that are allowed to access resources owned by the + organization. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`IpAllowListEntryOrder`): Ordering options for IP + allow list entries returned. (default: `{field: + ALLOW_LIST_VALUE, direction: ASC}`) + """ + + ip_allow_list_for_installed_apps_enabled_setting = sgqlc.types.Field( + sgqlc.types.non_null(IpAllowListForInstalledAppsEnabledSettingValue), graphql_name="ipAllowListForInstalledAppsEnabledSetting" + ) + """The setting value for whether the organization has IP allow list + configuration for installed GitHub Apps enabled. + """ + + is_verified = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isVerified") + """Whether the organization has verified its profile email and + website. + """ + + members_can_fork_private_repositories = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), graphql_name="membersCanForkPrivateRepositories" + ) + """Members can fork private repositories in this organization""" + + members_with_role = sgqlc.types.Field( + sgqlc.types.non_null(OrganizationMemberConnection), + graphql_name="membersWithRole", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users who are members of this organization. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + new_team_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="newTeamResourcePath") + """The HTTP path creating a new team""" + + new_team_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="newTeamUrl") + """The HTTP URL creating a new team""" + + notification_delivery_restriction_enabled_setting = sgqlc.types.Field( + sgqlc.types.non_null(NotificationRestrictionSettingValue), graphql_name="notificationDeliveryRestrictionEnabledSetting" + ) + """Indicates if email notification delivery for this organization is + restricted to verified or approved domains. + """ + + organization_billing_email = sgqlc.types.Field(String, graphql_name="organizationBillingEmail") + """The billing email for the organization.""" + + pending_members = sgqlc.types.Field( + sgqlc.types.non_null(UserConnection), + graphql_name="pendingMembers", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users who have been invited to join this organization. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + repository_migrations = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryMigrationConnection), + graphql_name="repositoryMigrations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("state", sgqlc.types.Arg(MigrationState, graphql_name="state", default=None)), + ("repository_name", sgqlc.types.Arg(String, graphql_name="repositoryName", default=None)), + ( + "order_by", + sgqlc.types.Arg(RepositoryMigrationOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "ASC"}), + ), + ) + ), + ) + """A list of all repository migrations for this organization. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `state` (`MigrationState`): Filter repository migrations by + state. + * `repository_name` (`String`): Filter repository migrations by + repository name. + * `order_by` (`RepositoryMigrationOrder`): Ordering options for + repository migrations returned. (default: `{field: CREATED_AT, + direction: ASC}`) + """ + + requires_two_factor_authentication = sgqlc.types.Field(Boolean, graphql_name="requiresTwoFactorAuthentication") + """When true the organization requires all members, billing managers, + and outside collaborators to enable two-factor authentication. + """ + + saml_identity_provider = sgqlc.types.Field("OrganizationIdentityProvider", graphql_name="samlIdentityProvider") + """The Organization's SAML identity providers""" + + team = sgqlc.types.Field( + "Team", + graphql_name="team", + args=sgqlc.types.ArgDict((("slug", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="slug", default=None)),)), + ) + """Find an organization's team by its slug. + + Arguments: + + * `slug` (`String!`): The name or slug of the team to find. + """ + + teams = sgqlc.types.Field( + sgqlc.types.non_null(TeamConnection), + graphql_name="teams", + args=sgqlc.types.ArgDict( + ( + ("privacy", sgqlc.types.Arg(TeamPrivacy, graphql_name="privacy", default=None)), + ("role", sgqlc.types.Arg(TeamRole, graphql_name="role", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ( + "user_logins", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="userLogins", default=None), + ), + ("order_by", sgqlc.types.Arg(TeamOrder, graphql_name="orderBy", default=None)), + ("ldap_mapped", sgqlc.types.Arg(Boolean, graphql_name="ldapMapped", default=None)), + ("root_teams_only", sgqlc.types.Arg(Boolean, graphql_name="rootTeamsOnly", default=False)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of teams in this organization. + + Arguments: + + * `privacy` (`TeamPrivacy`): If non-null, filters teams according + to privacy + * `role` (`TeamRole`): If non-null, filters teams according to + whether the viewer is an admin or member on team + * `query` (`String`): If non-null, filters teams with query on + team name and team slug + * `user_logins` (`[String!]`): User logins to filter by + * `order_by` (`TeamOrder`): Ordering options for teams returned + from the connection + * `ldap_mapped` (`Boolean`): If true, filters teams that are + mapped to an LDAP Group (Enterprise only) + * `root_teams_only` (`Boolean`): If true, restrict to only root + teams (default: `false`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + teams_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="teamsResourcePath") + """The HTTP path listing organization's teams""" + + teams_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="teamsUrl") + """The HTTP URL listing organization's teams""" + + twitter_username = sgqlc.types.Field(String, graphql_name="twitterUsername") + """The organization's Twitter username.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + viewer_can_administer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanAdminister") + """Organization is adminable by the viewer.""" + + viewer_can_create_repositories = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanCreateRepositories") + """Viewer can create repositories on this organization""" + + viewer_can_create_teams = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanCreateTeams") + """Viewer can create teams on this organization.""" + + viewer_is_amember = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerIsAMember") + """Viewer is an active member of this organization.""" + + viewer_is_following = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerIsFollowing") + """Whether or not this Organization is followed by the viewer.""" + + +class OrganizationIdentityProvider(sgqlc.types.Type, Node): + """An Identity Provider configured to provision SAML and SCIM + identities for Organizations + """ + + __schema__ = github_schema + __field_names__ = ("digest_method", "external_identities", "idp_certificate", "issuer", "organization", "signature_method", "sso_url") + digest_method = sgqlc.types.Field(URI, graphql_name="digestMethod") + """The digest algorithm used to sign SAML requests for the Identity + Provider. + """ + + external_identities = sgqlc.types.Field( + sgqlc.types.non_null(ExternalIdentityConnection), + graphql_name="externalIdentities", + args=sgqlc.types.ArgDict( + ( + ("members_only", sgqlc.types.Arg(Boolean, graphql_name="membersOnly", default=None)), + ("login", sgqlc.types.Arg(String, graphql_name="login", default=None)), + ("user_name", sgqlc.types.Arg(String, graphql_name="userName", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """External Identities provisioned by this Identity Provider + + Arguments: + + * `members_only` (`Boolean`): Filter to external identities with + valid org membership only + * `login` (`String`): Filter to external identities with the users + login + * `user_name` (`String`): Filter to external identities with the + users userName/NameID attribute + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + idp_certificate = sgqlc.types.Field(X509Certificate, graphql_name="idpCertificate") + """The x509 certificate used by the Identity Provider to sign + assertions and responses. + """ + + issuer = sgqlc.types.Field(String, graphql_name="issuer") + """The Issuer Entity ID for the SAML Identity Provider""" + + organization = sgqlc.types.Field(Organization, graphql_name="organization") + """Organization this Identity Provider belongs to""" + + signature_method = sgqlc.types.Field(URI, graphql_name="signatureMethod") + """The signature algorithm used to sign SAML requests for the + Identity Provider. + """ + + sso_url = sgqlc.types.Field(URI, graphql_name="ssoUrl") + """The URL endpoint for the Identity Provider's SAML SSO.""" + + +class OrganizationInvitation(sgqlc.types.Type, Node): + """An Invitation for a user to an organization.""" + + __schema__ = github_schema + __field_names__ = ("created_at", "email", "invitation_type", "invitee", "inviter", "organization", "role") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + email = sgqlc.types.Field(String, graphql_name="email") + """The email address of the user invited to the organization.""" + + invitation_type = sgqlc.types.Field(sgqlc.types.non_null(OrganizationInvitationType), graphql_name="invitationType") + """The type of invitation that was sent (e.g. email, user).""" + + invitee = sgqlc.types.Field("User", graphql_name="invitee") + """The user who was invited to the organization.""" + + inviter = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="inviter") + """The user who created the invitation.""" + + organization = sgqlc.types.Field(sgqlc.types.non_null(Organization), graphql_name="organization") + """The organization the invite is for""" + + role = sgqlc.types.Field(sgqlc.types.non_null(OrganizationInvitationRole), graphql_name="role") + """The user's pending role in the organization (e.g. member, owner).""" + + +class OrganizationTeamsHovercardContext(sgqlc.types.Type, HovercardContext): + """An organization teams hovercard context""" + + __schema__ = github_schema + __field_names__ = ("relevant_teams", "teams_resource_path", "teams_url", "total_team_count") + relevant_teams = sgqlc.types.Field( + sgqlc.types.non_null(TeamConnection), + graphql_name="relevantTeams", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Teams in this organization the user is a member of that are + relevant + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + teams_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="teamsResourcePath") + """The path for the full team list for this user""" + + teams_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="teamsUrl") + """The URL for the full team list for this user""" + + total_team_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalTeamCount") + """The total number of teams the user is on in the organization""" + + +class OrganizationsHovercardContext(sgqlc.types.Type, HovercardContext): + """An organization list hovercard context""" + + __schema__ = github_schema + __field_names__ = ("relevant_organizations", "total_organization_count") + relevant_organizations = sgqlc.types.Field( + sgqlc.types.non_null(OrganizationConnection), + graphql_name="relevantOrganizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Organizations this user is a member of that are relevant + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + total_organization_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="totalOrganizationCount") + """The total number of organizations this user is in""" + + +class Package(sgqlc.types.Type, Node): + """Information for an uploaded package.""" + + __schema__ = github_schema + __field_names__ = ("latest_version", "name", "package_type", "repository", "statistics", "version", "versions") + latest_version = sgqlc.types.Field("PackageVersion", graphql_name="latestVersion") + """Find the latest version for the package.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Identifies the name of the package.""" + + package_type = sgqlc.types.Field(sgqlc.types.non_null(PackageType), graphql_name="packageType") + """Identifies the type of the package.""" + + repository = sgqlc.types.Field("Repository", graphql_name="repository") + """The repository this package belongs to.""" + + statistics = sgqlc.types.Field(PackageStatistics, graphql_name="statistics") + """Statistics about package activity.""" + + version = sgqlc.types.Field( + "PackageVersion", + graphql_name="version", + args=sgqlc.types.ArgDict((("version", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="version", default=None)),)), + ) + """Find package version by version string. + + Arguments: + + * `version` (`String!`): The package version. + """ + + versions = sgqlc.types.Field( + sgqlc.types.non_null(PackageVersionConnection), + graphql_name="versions", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg(PackageVersionOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "DESC"}), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """list of versions for this package + + Arguments: + + * `order_by` (`PackageVersionOrder`): Ordering of the returned + packages. (default: `{field: CREATED_AT, direction: DESC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class PackageFile(sgqlc.types.Type, Node): + """A file in a package version.""" + + __schema__ = github_schema + __field_names__ = ("md5", "name", "package_version", "sha1", "sha256", "size", "updated_at", "url") + md5 = sgqlc.types.Field(String, graphql_name="md5") + """MD5 hash of the file.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Name of the file.""" + + package_version = sgqlc.types.Field("PackageVersion", graphql_name="packageVersion") + """The package version this file belongs to.""" + + sha1 = sgqlc.types.Field(String, graphql_name="sha1") + """SHA1 hash of the file.""" + + sha256 = sgqlc.types.Field(String, graphql_name="sha256") + """SHA256 hash of the file.""" + + size = sgqlc.types.Field(Int, graphql_name="size") + """Size of the file in bytes.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(URI, graphql_name="url") + """URL to download the asset.""" + + +class PackageTag(sgqlc.types.Type, Node): + """A version tag contains the mapping between a tag name and a + version. + """ + + __schema__ = github_schema + __field_names__ = ("name", "version") + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Identifies the tag name of the version.""" + + version = sgqlc.types.Field("PackageVersion", graphql_name="version") + """Version that the tag is associated with.""" + + +class PackageVersion(sgqlc.types.Type, Node): + """Information about a specific package version.""" + + __schema__ = github_schema + __field_names__ = ("files", "package", "platform", "pre_release", "readme", "release", "statistics", "summary", "version") + files = sgqlc.types.Field( + sgqlc.types.non_null(PackageFileConnection), + graphql_name="files", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg(PackageFileOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "ASC"}), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of files associated with this package version + + Arguments: + + * `order_by` (`PackageFileOrder`): Ordering of the returned + package files. (default: `{field: CREATED_AT, direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + package = sgqlc.types.Field(Package, graphql_name="package") + """The package associated with this version.""" + + platform = sgqlc.types.Field(String, graphql_name="platform") + """The platform this version was built for.""" + + pre_release = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="preRelease") + """Whether or not this version is a pre-release.""" + + readme = sgqlc.types.Field(String, graphql_name="readme") + """The README of this package version.""" + + release = sgqlc.types.Field("Release", graphql_name="release") + """The release associated with this package version.""" + + statistics = sgqlc.types.Field(PackageVersionStatistics, graphql_name="statistics") + """Statistics about package activity.""" + + summary = sgqlc.types.Field(String, graphql_name="summary") + """The package version summary.""" + + version = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="version") + """The version string.""" + + +class PinnedDiscussion(sgqlc.types.Type, Node, RepositoryNode): + """A Pinned Discussion is a discussion pinned to a repository's index + page. + """ + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "database_id", + "discussion", + "gradient_stop_colors", + "pattern", + "pinned_by", + "preconfigured_gradient", + "updated_at", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + discussion = sgqlc.types.Field(sgqlc.types.non_null(Discussion), graphql_name="discussion") + """The discussion that was pinned.""" + + gradient_stop_colors = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))), graphql_name="gradientStopColors" + ) + """Color stops of the chosen gradient""" + + pattern = sgqlc.types.Field(sgqlc.types.non_null(PinnedDiscussionPattern), graphql_name="pattern") + """Background texture pattern""" + + pinned_by = sgqlc.types.Field(sgqlc.types.non_null(Actor), graphql_name="pinnedBy") + """The actor that pinned this discussion.""" + + preconfigured_gradient = sgqlc.types.Field(PinnedDiscussionGradient, graphql_name="preconfiguredGradient") + """Preconfigured background gradient option""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class PinnedEvent(sgqlc.types.Type, Node): + """Represents a 'pinned' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "issue") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + issue = sgqlc.types.Field(sgqlc.types.non_null(Issue), graphql_name="issue") + """Identifies the issue associated with the event.""" + + +class PinnedIssue(sgqlc.types.Type, Node): + """A Pinned Issue is a issue pinned to a repository's index page.""" + + __schema__ = github_schema + __field_names__ = ("database_id", "issue", "pinned_by", "repository") + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + issue = sgqlc.types.Field(sgqlc.types.non_null(Issue), graphql_name="issue") + """The issue that was pinned.""" + + pinned_by = sgqlc.types.Field(sgqlc.types.non_null(Actor), graphql_name="pinnedBy") + """The actor that pinned this issue.""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository that this issue was pinned to.""" + + +class PrivateRepositoryForkingDisableAuditEntry( + sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a private_repository_forking.disable event.""" + + __schema__ = github_schema + __field_names__ = () + + +class PrivateRepositoryForkingEnableAuditEntry( + sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a private_repository_forking.enable event.""" + + __schema__ = github_schema + __field_names__ = () + + +class Project(sgqlc.types.Type, Node, Closable, Updatable): + """Projects manage issues, pull requests and notes within a project + owner. + """ + + __schema__ = github_schema + __field_names__ = ( + "body", + "body_html", + "columns", + "created_at", + "creator", + "database_id", + "name", + "number", + "owner", + "pending_cards", + "progress", + "resource_path", + "state", + "updated_at", + "url", + ) + body = sgqlc.types.Field(String, graphql_name="body") + """The project's description body.""" + + body_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="bodyHTML") + """The projects description body rendered to HTML.""" + + columns = sgqlc.types.Field( + sgqlc.types.non_null(ProjectColumnConnection), + graphql_name="columns", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of columns in the project + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who originally created the project.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The project's name.""" + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """The project's number.""" + + owner = sgqlc.types.Field(sgqlc.types.non_null(ProjectOwner), graphql_name="owner") + """The project's owner. Currently limited to repositories, + organizations, and users. + """ + + pending_cards = sgqlc.types.Field( + sgqlc.types.non_null(ProjectCardConnection), + graphql_name="pendingCards", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "archived_states", + sgqlc.types.Arg( + sgqlc.types.list_of(ProjectCardArchivedState), graphql_name="archivedStates", default=("ARCHIVED", "NOT_ARCHIVED") + ), + ), + ) + ), + ) + """List of pending cards in this project + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `archived_states` (`[ProjectCardArchivedState]`): A list of + archived states to filter the cards by (default: `[ARCHIVED, + NOT_ARCHIVED]`) + """ + + progress = sgqlc.types.Field(sgqlc.types.non_null(ProjectProgress), graphql_name="progress") + """Project progress details.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this project""" + + state = sgqlc.types.Field(sgqlc.types.non_null(ProjectState), graphql_name="state") + """Whether the project is open or closed.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this project""" + + +class ProjectCard(sgqlc.types.Type, Node): + """A card in a project.""" + + __schema__ = github_schema + __field_names__ = ( + "column", + "content", + "created_at", + "creator", + "database_id", + "is_archived", + "note", + "project", + "resource_path", + "state", + "updated_at", + "url", + ) + column = sgqlc.types.Field("ProjectColumn", graphql_name="column") + """The project column this card is associated under. A card may only + belong to one project column at a time. The column field will be + null if the card is created in a pending state and has yet to be + associated with a column. Once cards are associated with a column, + they will not become pending in the future. + """ + + content = sgqlc.types.Field("ProjectCardItem", graphql_name="content") + """The card content item""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who created this card""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + is_archived = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isArchived") + """Whether the card is archived""" + + note = sgqlc.types.Field(String, graphql_name="note") + """The card note""" + + project = sgqlc.types.Field(sgqlc.types.non_null(Project), graphql_name="project") + """The project that contains this card.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this card""" + + state = sgqlc.types.Field(ProjectCardState, graphql_name="state") + """The state of ProjectCard""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this card""" + + +class ProjectColumn(sgqlc.types.Type, Node): + """A column inside a project.""" + + __schema__ = github_schema + __field_names__ = ("cards", "created_at", "database_id", "name", "project", "purpose", "resource_path", "updated_at", "url") + cards = sgqlc.types.Field( + sgqlc.types.non_null(ProjectCardConnection), + graphql_name="cards", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "archived_states", + sgqlc.types.Arg( + sgqlc.types.list_of(ProjectCardArchivedState), graphql_name="archivedStates", default=("ARCHIVED", "NOT_ARCHIVED") + ), + ), + ) + ), + ) + """List of cards in the column + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `archived_states` (`[ProjectCardArchivedState]`): A list of + archived states to filter the cards by (default: `[ARCHIVED, + NOT_ARCHIVED]`) + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The project column's name.""" + + project = sgqlc.types.Field(sgqlc.types.non_null(Project), graphql_name="project") + """The project that contains this column.""" + + purpose = sgqlc.types.Field(ProjectColumnPurpose, graphql_name="purpose") + """The semantic purpose of the column""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this project column""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this project column""" + + +class ProjectNext(sgqlc.types.Type, Node, Closable, Updatable): + """New projects that manage issues, pull requests and drafts using + tables and boards. + """ + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "creator", + "database_id", + "description", + "fields", + "items", + "number", + "owner", + "public", + "repositories", + "resource_path", + "short_description", + "title", + "updated_at", + "url", + "views", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who originally created the project.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The project's description.""" + + fields = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextFieldConnection), + graphql_name="fields", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of fields in the project + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + items = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextItemConnection), + graphql_name="items", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of items in the project + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """The project's number.""" + + owner = sgqlc.types.Field(sgqlc.types.non_null(ProjectNextOwner), graphql_name="owner") + """The project's owner. Currently limited to organizations and users.""" + + public = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="public") + """Returns true if the project is public.""" + + repositories = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryConnection), + graphql_name="repositories", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The repositories the project is linked to. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this project""" + + short_description = sgqlc.types.Field(String, graphql_name="shortDescription") + """The project's short description.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The project's name.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this project""" + + views = sgqlc.types.Field( + sgqlc.types.non_null(ProjectViewConnection), + graphql_name="views", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of views in the project + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class ProjectNextField(sgqlc.types.Type, ProjectNextFieldCommon, Node): + """A field inside a project.""" + + __schema__ = github_schema + __field_names__ = () + + +class ProjectNextItem(sgqlc.types.Type, Node): + """An item within a new Project.""" + + __schema__ = github_schema + __field_names__ = ( + "content", + "created_at", + "creator", + "database_id", + "field_values", + "is_archived", + "project", + "title", + "type", + "updated_at", + ) + content = sgqlc.types.Field("ProjectNextItemContent", graphql_name="content") + """The content of the referenced draft issue, issue, or pull request""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who created the item.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + field_values = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextItemFieldValueConnection), + graphql_name="fieldValues", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of field values + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + is_archived = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isArchived") + """Whether the item is archived.""" + + project = sgqlc.types.Field(sgqlc.types.non_null(ProjectNext), graphql_name="project") + """The project that contains this item.""" + + title = sgqlc.types.Field(String, graphql_name="title") + """The title of the item""" + + type = sgqlc.types.Field(sgqlc.types.non_null(ProjectItemType), graphql_name="type") + """The type of the item.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class ProjectNextItemFieldValue(sgqlc.types.Type, Node): + """An value of a field in an item of a new Project.""" + + __schema__ = github_schema + __field_names__ = ("created_at", "creator", "database_id", "project_field", "project_item", "updated_at", "value") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who created the item.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + project_field = sgqlc.types.Field(sgqlc.types.non_null(ProjectNextField), graphql_name="projectField") + """The project field that contains this value.""" + + project_item = sgqlc.types.Field(sgqlc.types.non_null(ProjectNextItem), graphql_name="projectItem") + """The project item that contains this value.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + value = sgqlc.types.Field(String, graphql_name="value") + """The value of a field""" + + +class ProjectView(sgqlc.types.Type, Node): + """A view within a Project.""" + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "database_id", + "filter", + "group_by", + "items", + "layout", + "name", + "number", + "project", + "sort_by", + "updated_at", + "vertical_group_by", + "visible_fields", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + filter = sgqlc.types.Field(String, graphql_name="filter") + """The project view's filter.""" + + group_by = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(Int)), graphql_name="groupBy") + """The view's group-by field.""" + + items = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextItemConnection), + graphql_name="items", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The view's filtered items. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + layout = sgqlc.types.Field(sgqlc.types.non_null(ProjectViewLayout), graphql_name="layout") + """The project view's layout.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The project view's name.""" + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """The project view's number.""" + + project = sgqlc.types.Field(sgqlc.types.non_null(ProjectNext), graphql_name="project") + """The project that contains this view.""" + + sort_by = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(SortBy)), graphql_name="sortBy") + """The view's sort-by config.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + vertical_group_by = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(Int)), graphql_name="verticalGroupBy") + """The view's vertical-group-by field.""" + + visible_fields = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(Int)), graphql_name="visibleFields") + """The view's visible fields.""" + + +class PublicKey(sgqlc.types.Type, Node): + """A user's public key.""" + + __schema__ = github_schema + __field_names__ = ("accessed_at", "created_at", "fingerprint", "is_read_only", "key", "updated_at") + accessed_at = sgqlc.types.Field(DateTime, graphql_name="accessedAt") + """The last time this authorization was used to perform an action. + Values will be null for keys not owned by the user. + """ + + created_at = sgqlc.types.Field(DateTime, graphql_name="createdAt") + """Identifies the date and time when the key was created. Keys + created before March 5th, 2014 have inaccurate values. Values will + be null for keys not owned by the user. + """ + + fingerprint = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fingerprint") + """The fingerprint for this PublicKey.""" + + is_read_only = sgqlc.types.Field(Boolean, graphql_name="isReadOnly") + """Whether this PublicKey is read-only or not. Values will be null + for keys not owned by the user. + """ + + key = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="key") + """The public key string.""" + + updated_at = sgqlc.types.Field(DateTime, graphql_name="updatedAt") + """Identifies the date and time when the key was updated. Keys + created before March 5th, 2014 may have inaccurate values. Values + will be null for keys not owned by the user. + """ + + +class PullRequest( + sgqlc.types.Type, + Node, + Assignable, + Closable, + Comment, + Updatable, + UpdatableComment, + Labelable, + Lockable, + Reactable, + RepositoryNode, + Subscribable, + UniformResourceLocatable, + ProjectNextOwner, +): + """A repository pull request.""" + + __schema__ = github_schema + __field_names__ = ( + "additions", + "auto_merge_request", + "base_ref", + "base_ref_name", + "base_ref_oid", + "base_repository", + "can_be_rebased", + "changed_files", + "checks_resource_path", + "checks_url", + "closing_issues_references", + "comments", + "commits", + "deletions", + "files", + "head_ref", + "head_ref_name", + "head_ref_oid", + "head_repository", + "head_repository_owner", + "hovercard", + "is_cross_repository", + "is_draft", + "is_read_by_viewer", + "latest_opinionated_reviews", + "latest_reviews", + "maintainer_can_modify", + "merge_commit", + "merge_state_status", + "mergeable", + "merged", + "merged_at", + "merged_by", + "milestone", + "number", + "participants", + "permalink", + "potential_merge_commit", + "project_cards", + "project_next_items", + "revert_resource_path", + "revert_url", + "review_decision", + "review_requests", + "review_threads", + "reviews", + "state", + "suggested_reviewers", + "timeline_items", + "title", + "title_html", + "viewer_can_apply_suggestion", + "viewer_can_delete_head_ref", + "viewer_can_disable_auto_merge", + "viewer_can_enable_auto_merge", + "viewer_can_merge_as_admin", + "viewer_latest_review", + "viewer_latest_review_request", + "viewer_merge_body_text", + "viewer_merge_headline_text", + ) + additions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="additions") + """The number of additions in this pull request.""" + + auto_merge_request = sgqlc.types.Field(AutoMergeRequest, graphql_name="autoMergeRequest") + """Returns the auto-merge request object if one exists for this pull + request. + """ + + base_ref = sgqlc.types.Field("Ref", graphql_name="baseRef") + """Identifies the base Ref associated with the pull request.""" + + base_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="baseRefName") + """Identifies the name of the base Ref associated with the pull + request, even if the ref has been deleted. + """ + + base_ref_oid = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="baseRefOid") + """Identifies the oid of the base ref associated with the pull + request, even if the ref has been deleted. + """ + + base_repository = sgqlc.types.Field("Repository", graphql_name="baseRepository") + """The repository associated with this pull request's base Ref.""" + + can_be_rebased = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="canBeRebased") + """Whether or not the pull request is rebaseable.""" + + changed_files = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="changedFiles") + """The number of changed files in this pull request.""" + + checks_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="checksResourcePath") + """The HTTP path for the checks of this pull request.""" + + checks_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="checksUrl") + """The HTTP URL for the checks of this pull request.""" + + closing_issues_references = sgqlc.types.Field( + IssueConnection, + graphql_name="closingIssuesReferences", + args=sgqlc.types.ArgDict( + ( + ("user_linked_only", sgqlc.types.Arg(Boolean, graphql_name="userLinkedOnly", default=False)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """List of issues that were may be closed by this pull request + + Arguments: + + * `user_linked_only` (`Boolean`): Return only manually linked + Issues (default: `false`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`IssueOrder`): Ordering options for issues returned + from the connection + """ + + comments = sgqlc.types.Field( + sgqlc.types.non_null(IssueCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(IssueCommentOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of comments associated with the pull request. + + Arguments: + + * `order_by` (`IssueCommentOrder`): Ordering options for issue + comments returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + commits = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestCommitConnection), + graphql_name="commits", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of commits present in this pull request's head branch not + present in the base branch. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + deletions = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="deletions") + """The number of deletions in this pull request.""" + + files = sgqlc.types.Field( + PullRequestChangedFileConnection, + graphql_name="files", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Lists the files changed within this pull request. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + head_ref = sgqlc.types.Field("Ref", graphql_name="headRef") + """Identifies the head Ref associated with the pull request.""" + + head_ref_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="headRefName") + """Identifies the name of the head Ref associated with the pull + request, even if the ref has been deleted. + """ + + head_ref_oid = sgqlc.types.Field(sgqlc.types.non_null(GitObjectID), graphql_name="headRefOid") + """Identifies the oid of the head ref associated with the pull + request, even if the ref has been deleted. + """ + + head_repository = sgqlc.types.Field("Repository", graphql_name="headRepository") + """The repository associated with this pull request's head Ref.""" + + head_repository_owner = sgqlc.types.Field(RepositoryOwner, graphql_name="headRepositoryOwner") + """The owner of the repository associated with this pull request's + head Ref. + """ + + hovercard = sgqlc.types.Field( + sgqlc.types.non_null(Hovercard), + graphql_name="hovercard", + args=sgqlc.types.ArgDict( + (("include_notification_contexts", sgqlc.types.Arg(Boolean, graphql_name="includeNotificationContexts", default=True)),) + ), + ) + """The hovercard information for this issue + + Arguments: + + * `include_notification_contexts` (`Boolean`): Whether or not to + include notification contexts (default: `true`) + """ + + is_cross_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCrossRepository") + """The head and base repositories are different.""" + + is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft") + """Identifies if the pull request is a draft.""" + + is_read_by_viewer = sgqlc.types.Field(Boolean, graphql_name="isReadByViewer") + """Is this pull request read by the viewer""" + + latest_opinionated_reviews = sgqlc.types.Field( + PullRequestReviewConnection, + graphql_name="latestOpinionatedReviews", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("writers_only", sgqlc.types.Arg(Boolean, graphql_name="writersOnly", default=False)), + ) + ), + ) + """A list of latest reviews per user associated with the pull + request. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `writers_only` (`Boolean`): Only return reviews from user who + have write access to the repository (default: `false`) + """ + + latest_reviews = sgqlc.types.Field( + PullRequestReviewConnection, + graphql_name="latestReviews", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of latest reviews per user associated with the pull request + that are not also pending review. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + maintainer_can_modify = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="maintainerCanModify") + """Indicates whether maintainers can modify the pull request.""" + + merge_commit = sgqlc.types.Field(Commit, graphql_name="mergeCommit") + """The commit that was created when this pull request was merged.""" + + merge_state_status = sgqlc.types.Field(sgqlc.types.non_null(MergeStateStatus), graphql_name="mergeStateStatus") + """Detailed information about the current pull request merge state + status. + """ + + mergeable = sgqlc.types.Field(sgqlc.types.non_null(MergeableState), graphql_name="mergeable") + """Whether or not the pull request can be merged based on the + existence of merge conflicts. + """ + + merged = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="merged") + """Whether or not the pull request was merged.""" + + merged_at = sgqlc.types.Field(DateTime, graphql_name="mergedAt") + """The date and time that the pull request was merged.""" + + merged_by = sgqlc.types.Field(Actor, graphql_name="mergedBy") + """The actor who merged the pull request.""" + + milestone = sgqlc.types.Field(Milestone, graphql_name="milestone") + """Identifies the milestone associated with the pull request.""" + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """Identifies the pull request number.""" + + participants = sgqlc.types.Field( + sgqlc.types.non_null(UserConnection), + graphql_name="participants", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of Users that are participating in the Pull Request + conversation. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + permalink = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="permalink") + """The permalink to the pull request.""" + + potential_merge_commit = sgqlc.types.Field(Commit, graphql_name="potentialMergeCommit") + """The commit that GitHub automatically generated to test if this + pull request could be merged. This field will not return a value + if the pull request is merged, or if the test merge commit is + still being generated. See the `mergeable` field for more details + on the mergeability of the pull request. + """ + + project_cards = sgqlc.types.Field( + sgqlc.types.non_null(ProjectCardConnection), + graphql_name="projectCards", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "archived_states", + sgqlc.types.Arg( + sgqlc.types.list_of(ProjectCardArchivedState), graphql_name="archivedStates", default=("ARCHIVED", "NOT_ARCHIVED") + ), + ), + ) + ), + ) + """List of project cards associated with this pull request. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `archived_states` (`[ProjectCardArchivedState]`): A list of + archived states to filter the cards by (default: `[ARCHIVED, + NOT_ARCHIVED]`) + """ + + project_next_items = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextItemConnection), + graphql_name="projectNextItems", + args=sgqlc.types.ArgDict( + ( + ("include_archived", sgqlc.types.Arg(Boolean, graphql_name="includeArchived", default=True)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of project (beta) items associated with this pull request. + + Arguments: + + * `include_archived` (`Boolean`): Include archived items. + (default: `true`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + revert_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="revertResourcePath") + """The HTTP path for reverting this pull request.""" + + revert_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="revertUrl") + """The HTTP URL for reverting this pull request.""" + + review_decision = sgqlc.types.Field(PullRequestReviewDecision, graphql_name="reviewDecision") + """The current status of this pull request with respect to code + review. + """ + + review_requests = sgqlc.types.Field( + ReviewRequestConnection, + graphql_name="reviewRequests", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of review requests associated with the pull request. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + review_threads = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestReviewThreadConnection), + graphql_name="reviewThreads", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The list of all review threads for this pull request. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + reviews = sgqlc.types.Field( + PullRequestReviewConnection, + graphql_name="reviews", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "states", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PullRequestReviewState)), graphql_name="states", default=None), + ), + ("author", sgqlc.types.Arg(String, graphql_name="author", default=None)), + ) + ), + ) + """A list of reviews associated with the pull request. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `states` (`[PullRequestReviewState!]`): A list of states to + filter the reviews. + * `author` (`String`): Filter by author of the review. + """ + + state = sgqlc.types.Field(sgqlc.types.non_null(PullRequestState), graphql_name="state") + """Identifies the state of the pull request.""" + + suggested_reviewers = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(SuggestedReviewer)), graphql_name="suggestedReviewers") + """A list of reviewer suggestions based on commit history and past + review comments. + """ + + timeline_items = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestTimelineItemsConnection), + graphql_name="timelineItems", + args=sgqlc.types.ArgDict( + ( + ("since", sgqlc.types.Arg(DateTime, graphql_name="since", default=None)), + ("skip", sgqlc.types.Arg(Int, graphql_name="skip", default=None)), + ( + "item_types", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(PullRequestTimelineItemsItemType)), graphql_name="itemTypes", default=None + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of events, comments, commits, etc. associated with the pull + request. + + Arguments: + + * `since` (`DateTime`): Filter timeline items by a `since` + timestamp. + * `skip` (`Int`): Skips the first _n_ elements in the list. + * `item_types` (`[PullRequestTimelineItemsItemType!]`): Filter + timeline items by type. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """Identifies the pull request title.""" + + title_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="titleHTML") + """Identifies the pull request title rendered to HTML.""" + + viewer_can_apply_suggestion = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanApplySuggestion") + """Whether or not the viewer can apply suggestion.""" + + viewer_can_delete_head_ref = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanDeleteHeadRef") + """Check if the viewer can restore the deleted head ref.""" + + viewer_can_disable_auto_merge = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanDisableAutoMerge") + """Whether or not the viewer can disable auto-merge""" + + viewer_can_enable_auto_merge = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanEnableAutoMerge") + """Whether or not the viewer can enable auto-merge""" + + viewer_can_merge_as_admin = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanMergeAsAdmin") + """Indicates whether the viewer can bypass branch protections and + merge the pull request immediately + """ + + viewer_latest_review = sgqlc.types.Field("PullRequestReview", graphql_name="viewerLatestReview") + """The latest review given from the viewer.""" + + viewer_latest_review_request = sgqlc.types.Field("ReviewRequest", graphql_name="viewerLatestReviewRequest") + """The person who has requested the viewer for review on this pull + request. + """ + + viewer_merge_body_text = sgqlc.types.Field( + sgqlc.types.non_null(String), + graphql_name="viewerMergeBodyText", + args=sgqlc.types.ArgDict((("merge_type", sgqlc.types.Arg(PullRequestMergeMethod, graphql_name="mergeType", default=None)),)), + ) + """The merge body text for the viewer and method. + + Arguments: + + * `merge_type` (`PullRequestMergeMethod`): The merge method for + the message. + """ + + viewer_merge_headline_text = sgqlc.types.Field( + sgqlc.types.non_null(String), + graphql_name="viewerMergeHeadlineText", + args=sgqlc.types.ArgDict((("merge_type", sgqlc.types.Arg(PullRequestMergeMethod, graphql_name="mergeType", default=None)),)), + ) + """The merge headline text for the viewer and method. + + Arguments: + + * `merge_type` (`PullRequestMergeMethod`): The merge method for + the message. + """ + + +class PullRequestCommit(sgqlc.types.Type, Node, UniformResourceLocatable): + """Represents a Git commit part of a pull request.""" + + __schema__ = github_schema + __field_names__ = ("commit", "pull_request") + commit = sgqlc.types.Field(sgqlc.types.non_null(Commit), graphql_name="commit") + """The Git commit object""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """The pull request this commit belongs to""" + + +class PullRequestCommitCommentThread(sgqlc.types.Type, RepositoryNode, Node): + """Represents a commit comment thread part of a pull request.""" + + __schema__ = github_schema + __field_names__ = ("comments", "commit", "path", "position", "pull_request") + comments = sgqlc.types.Field( + sgqlc.types.non_null(CommitCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The comments that exist in this thread. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + commit = sgqlc.types.Field(sgqlc.types.non_null(Commit), graphql_name="commit") + """The commit the comments were made on.""" + + path = sgqlc.types.Field(String, graphql_name="path") + """The file the comments were made on.""" + + position = sgqlc.types.Field(Int, graphql_name="position") + """The position in the diff for the commit that the comment was made + on. + """ + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """The pull request this commit comment thread belongs to""" + + +class PullRequestReview(sgqlc.types.Type, Node, Comment, Deletable, Updatable, UpdatableComment, Reactable, RepositoryNode): + """A review object for a given pull request.""" + + __schema__ = github_schema + __field_names__ = ( + "author_can_push_to_repository", + "comments", + "commit", + "on_behalf_of", + "pull_request", + "resource_path", + "state", + "submitted_at", + "url", + ) + author_can_push_to_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="authorCanPushToRepository") + """Indicates whether the author of this review has push access to the + repository. + """ + + comments = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestReviewCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of review comments for the current pull request review. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """Identifies the commit associated with this pull request review.""" + + on_behalf_of = sgqlc.types.Field( + sgqlc.types.non_null(TeamConnection), + graphql_name="onBehalfOf", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of teams that this review was made on behalf of. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """Identifies the pull request associated with this pull request + review. + """ + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path permalink for this PullRequestReview.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(PullRequestReviewState), graphql_name="state") + """Identifies the current state of the pull request review.""" + + submitted_at = sgqlc.types.Field(DateTime, graphql_name="submittedAt") + """Identifies when the Pull Request Review was submitted""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL permalink for this PullRequestReview.""" + + +class PullRequestReviewComment( + sgqlc.types.Type, Node, Comment, Deletable, Minimizable, Updatable, UpdatableComment, Reactable, RepositoryNode +): + """A review comment associated with a given repository pull request.""" + + __schema__ = github_schema + __field_names__ = ( + "commit", + "diff_hunk", + "drafted_at", + "original_commit", + "original_position", + "outdated", + "path", + "position", + "pull_request", + "pull_request_review", + "reply_to", + "resource_path", + "state", + "url", + ) + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """Identifies the commit associated with the comment.""" + + diff_hunk = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="diffHunk") + """The diff hunk to which the comment applies.""" + + drafted_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="draftedAt") + """Identifies when the comment was created in a draft state.""" + + original_commit = sgqlc.types.Field(Commit, graphql_name="originalCommit") + """Identifies the original commit associated with the comment.""" + + original_position = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="originalPosition") + """The original line index in the diff to which the comment applies.""" + + outdated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="outdated") + """Identifies when the comment body is outdated""" + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """The path to which the comment applies.""" + + position = sgqlc.types.Field(Int, graphql_name="position") + """The line index in the diff to which the comment applies.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """The pull request associated with this review comment.""" + + pull_request_review = sgqlc.types.Field(PullRequestReview, graphql_name="pullRequestReview") + """The pull request review associated with this review comment.""" + + reply_to = sgqlc.types.Field("PullRequestReviewComment", graphql_name="replyTo") + """The comment this is a reply to.""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path permalink for this review comment.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(PullRequestReviewCommentState), graphql_name="state") + """Identifies the state of the comment.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL permalink for this review comment.""" + + +class PullRequestReviewThread(sgqlc.types.Type, Node): + """A threaded list of comments for a given pull request.""" + + __schema__ = github_schema + __field_names__ = ( + "comments", + "diff_side", + "is_collapsed", + "is_outdated", + "is_resolved", + "line", + "original_line", + "original_start_line", + "path", + "pull_request", + "repository", + "resolved_by", + "start_diff_side", + "start_line", + "viewer_can_reply", + "viewer_can_resolve", + "viewer_can_unresolve", + ) + comments = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestReviewCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("skip", sgqlc.types.Arg(Int, graphql_name="skip", default=None)), + ) + ), + ) + """A list of pull request comments associated with the thread. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `skip` (`Int`): Skips the first _n_ elements in the list. + """ + + diff_side = sgqlc.types.Field(sgqlc.types.non_null(DiffSide), graphql_name="diffSide") + """The side of the diff on which this thread was placed.""" + + is_collapsed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCollapsed") + """Whether or not the thread has been collapsed (resolved)""" + + is_outdated = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isOutdated") + """Indicates whether this thread was outdated by newer changes.""" + + is_resolved = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isResolved") + """Whether this thread has been resolved""" + + line = sgqlc.types.Field(Int, graphql_name="line") + """The line in the file to which this thread refers""" + + original_line = sgqlc.types.Field(Int, graphql_name="originalLine") + """The original line in the file to which this thread refers.""" + + original_start_line = sgqlc.types.Field(Int, graphql_name="originalStartLine") + """The original start line in the file to which this thread refers + (multi-line only). + """ + + path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="path") + """Identifies the file path of this thread.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """Identifies the pull request associated with this thread.""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """Identifies the repository associated with this thread.""" + + resolved_by = sgqlc.types.Field("User", graphql_name="resolvedBy") + """The user who resolved this thread""" + + start_diff_side = sgqlc.types.Field(DiffSide, graphql_name="startDiffSide") + """The side of the diff that the first line of the thread starts on + (multi-line only) + """ + + start_line = sgqlc.types.Field(Int, graphql_name="startLine") + """The start line in the file to which this thread refers (multi-line + only) + """ + + viewer_can_reply = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanReply") + """Indicates whether the current viewer can reply to this thread.""" + + viewer_can_resolve = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanResolve") + """Whether or not the viewer can resolve this thread""" + + viewer_can_unresolve = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanUnresolve") + """Whether or not the viewer can unresolve this thread""" + + +class Push(sgqlc.types.Type, Node): + """A Git push.""" + + __schema__ = github_schema + __field_names__ = ("next_sha", "permalink", "previous_sha", "pusher", "repository") + next_sha = sgqlc.types.Field(GitObjectID, graphql_name="nextSha") + """The SHA after the push""" + + permalink = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="permalink") + """The permalink for this push.""" + + previous_sha = sgqlc.types.Field(GitObjectID, graphql_name="previousSha") + """The SHA before the push""" + + pusher = sgqlc.types.Field(sgqlc.types.non_null(Actor), graphql_name="pusher") + """The actor who pushed""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository that was pushed to""" + + +class PushAllowance(sgqlc.types.Type, Node): + """A team, user, or app who has the ability to push to a protected + branch. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "branch_protection_rule") + actor = sgqlc.types.Field("PushAllowanceActor", graphql_name="actor") + """The actor that can push.""" + + branch_protection_rule = sgqlc.types.Field(BranchProtectionRule, graphql_name="branchProtectionRule") + """Identifies the branch protection rule associated with the allowed + user, team, or app. + """ + + +class Reaction(sgqlc.types.Type, Node): + """An emoji reaction to a particular piece of content.""" + + __schema__ = github_schema + __field_names__ = ("content", "created_at", "database_id", "reactable", "user") + content = sgqlc.types.Field(sgqlc.types.non_null(ReactionContent), graphql_name="content") + """Identifies the emoji reaction.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + reactable = sgqlc.types.Field(sgqlc.types.non_null(Reactable), graphql_name="reactable") + """The reactable piece of content""" + + user = sgqlc.types.Field("User", graphql_name="user") + """Identifies the user who created this reaction.""" + + +class ReadyForReviewEvent(sgqlc.types.Type, Node, UniformResourceLocatable): + """Represents a 'ready_for_review' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "pull_request") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + +class Ref(sgqlc.types.Type, Node): + """Represents a Git reference.""" + + __schema__ = github_schema + __field_names__ = ("associated_pull_requests", "branch_protection_rule", "name", "prefix", "ref_update_rule", "repository", "target") + associated_pull_requests = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestConnection), + graphql_name="associatedPullRequests", + args=sgqlc.types.ArgDict( + ( + ( + "states", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PullRequestState)), graphql_name="states", default=None), + ), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("head_ref_name", sgqlc.types.Arg(String, graphql_name="headRefName", default=None)), + ("base_ref_name", sgqlc.types.Arg(String, graphql_name="baseRefName", default=None)), + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pull requests with this ref as the head ref. + + Arguments: + + * `states` (`[PullRequestState!]`): A list of states to filter the + pull requests by. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `head_ref_name` (`String`): The head ref name to filter the pull + requests by. + * `base_ref_name` (`String`): The base ref name to filter the pull + requests by. + * `order_by` (`IssueOrder`): Ordering options for pull requests + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + branch_protection_rule = sgqlc.types.Field(BranchProtectionRule, graphql_name="branchProtectionRule") + """Branch protection rules for this ref""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The ref name.""" + + prefix = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="prefix") + """The ref's prefix, such as `refs/heads/` or `refs/tags/`.""" + + ref_update_rule = sgqlc.types.Field(RefUpdateRule, graphql_name="refUpdateRule") + """Branch protection rules that are viewable by non-admins""" + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository the ref belongs to.""" + + target = sgqlc.types.Field(GitObject, graphql_name="target") + """The object the ref points to. Returns null when object does not + exist. + """ + + +class ReferencedEvent(sgqlc.types.Type, Node): + """Represents a 'referenced' event on a given `ReferencedSubject`.""" + + __schema__ = github_schema + __field_names__ = ("actor", "commit", "commit_repository", "created_at", "is_cross_repository", "is_direct_reference", "subject") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """Identifies the commit associated with the 'referenced' event.""" + + commit_repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="commitRepository") + """Identifies the repository associated with the 'referenced' event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + is_cross_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCrossRepository") + """Reference originated in a different repository.""" + + is_direct_reference = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDirectReference") + """Checks if the commit message itself references the subject. Can be + false in the case of a commit comment reference. + """ + + subject = sgqlc.types.Field(sgqlc.types.non_null("ReferencedSubject"), graphql_name="subject") + """Object referenced by event.""" + + +class Release(sgqlc.types.Type, Node, UniformResourceLocatable, Reactable): + """A release contains the content for a release.""" + + __schema__ = github_schema + __field_names__ = ( + "author", + "created_at", + "description", + "description_html", + "is_draft", + "is_latest", + "is_prerelease", + "mentions", + "name", + "published_at", + "release_assets", + "repository", + "short_description_html", + "tag", + "tag_commit", + "tag_name", + "updated_at", + ) + author = sgqlc.types.Field("User", graphql_name="author") + """The author of the release""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The description of the release.""" + + description_html = sgqlc.types.Field(HTML, graphql_name="descriptionHTML") + """The description of this release rendered to HTML.""" + + is_draft = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDraft") + """Whether or not the release is a draft""" + + is_latest = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isLatest") + """Whether or not the release is the latest releast""" + + is_prerelease = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPrerelease") + """Whether or not the release is a prerelease""" + + mentions = sgqlc.types.Field( + UserConnection, + graphql_name="mentions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users mentioned in the release description + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + name = sgqlc.types.Field(String, graphql_name="name") + """The title of the release.""" + + published_at = sgqlc.types.Field(DateTime, graphql_name="publishedAt") + """Identifies the date and time when the release was created.""" + + release_assets = sgqlc.types.Field( + sgqlc.types.non_null(ReleaseAssetConnection), + graphql_name="releaseAssets", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("name", sgqlc.types.Arg(String, graphql_name="name", default=None)), + ) + ), + ) + """List of releases assets which are dependent on this release. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `name` (`String`): A list of names to filter the assets by. + """ + + repository = sgqlc.types.Field(sgqlc.types.non_null("Repository"), graphql_name="repository") + """The repository that the release belongs to.""" + + short_description_html = sgqlc.types.Field( + HTML, + graphql_name="shortDescriptionHTML", + args=sgqlc.types.ArgDict((("limit", sgqlc.types.Arg(Int, graphql_name="limit", default=200)),)), + ) + """A description of the release, rendered to HTML without any links + in it. + + Arguments: + + * `limit` (`Int`): How many characters to return. (default: `200`) + """ + + tag = sgqlc.types.Field(Ref, graphql_name="tag") + """The Git tag the release points to""" + + tag_commit = sgqlc.types.Field(Commit, graphql_name="tagCommit") + """The tag commit for this release.""" + + tag_name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="tagName") + """The name of the release's Git tag""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class ReleaseAsset(sgqlc.types.Type, Node): + """A release asset contains the content for a release asset.""" + + __schema__ = github_schema + __field_names__ = ( + "content_type", + "created_at", + "download_count", + "download_url", + "name", + "release", + "size", + "updated_at", + "uploaded_by", + "url", + ) + content_type = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="contentType") + """The asset's content-type""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + download_count = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="downloadCount") + """The number of times this asset was downloaded""" + + download_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="downloadUrl") + """Identifies the URL where you can download the release asset via + the browser. + """ + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """Identifies the title of the release asset.""" + + release = sgqlc.types.Field(Release, graphql_name="release") + """Release that the asset is associated with""" + + size = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="size") + """The size (in bytes) of the asset""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + uploaded_by = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="uploadedBy") + """The user that performed the upload""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """Identifies the URL of the release asset.""" + + +class RemovedFromProjectEvent(sgqlc.types.Type, Node): + """Represents a 'removed_from_project' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "database_id") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + +class RenamedTitleEvent(sgqlc.types.Type, Node): + """Represents a 'renamed' event on a given issue or pull request""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "current_title", "previous_title", "subject") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + current_title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="currentTitle") + """Identifies the current title of the issue or pull request.""" + + previous_title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="previousTitle") + """Identifies the previous title of the issue or pull request.""" + + subject = sgqlc.types.Field(sgqlc.types.non_null("RenamedTitleSubject"), graphql_name="subject") + """Subject that was renamed.""" + + +class ReopenedEvent(sgqlc.types.Type, Node): + """Represents a 'reopened' event on any `Closable`.""" + + __schema__ = github_schema + __field_names__ = ("actor", "closable", "created_at", "state_reason") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + closable = sgqlc.types.Field(sgqlc.types.non_null(Closable), graphql_name="closable") + """Object that was reopened.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + state_reason = sgqlc.types.Field(IssueStateReason, graphql_name="stateReason") + """The reason the issue state was changed to open.""" + + +class RepoAccessAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData): + """Audit log entry for a repo.access event.""" + + __schema__ = github_schema + __field_names__ = ("visibility",) + visibility = sgqlc.types.Field(RepoAccessAuditEntryVisibility, graphql_name="visibility") + """The visibility of the repository""" + + +class RepoAddMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData): + """Audit log entry for a repo.add_member event.""" + + __schema__ = github_schema + __field_names__ = ("visibility",) + visibility = sgqlc.types.Field(RepoAddMemberAuditEntryVisibility, graphql_name="visibility") + """The visibility of the repository""" + + +class RepoAddTopicAuditEntry(sgqlc.types.Type, Node, AuditEntry, RepositoryAuditEntryData, OrganizationAuditEntryData, TopicAuditEntryData): + """Audit log entry for a repo.add_topic event.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepoArchivedAuditEntry(sgqlc.types.Type, Node, AuditEntry, RepositoryAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a repo.archived event.""" + + __schema__ = github_schema + __field_names__ = ("visibility",) + visibility = sgqlc.types.Field(RepoArchivedAuditEntryVisibility, graphql_name="visibility") + """The visibility of the repository""" + + +class RepoChangeMergeSettingAuditEntry(sgqlc.types.Type, Node, AuditEntry, RepositoryAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a repo.change_merge_setting event.""" + + __schema__ = github_schema + __field_names__ = ("is_enabled", "merge_type") + is_enabled = sgqlc.types.Field(Boolean, graphql_name="isEnabled") + """Whether the change was to enable (true) or disable (false) the + merge type + """ + + merge_type = sgqlc.types.Field(RepoChangeMergeSettingAuditEntryMergeType, graphql_name="mergeType") + """The merge method affected by the change""" + + +class RepoConfigDisableAnonymousGitAccessAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a repo.config.disable_anonymous_git_access + event. + """ + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigDisableCollaboratorsOnlyAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a repo.config.disable_collaborators_only + event. + """ + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigDisableContributorsOnlyAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData): + """Audit log entry for a repo.config.disable_contributors_only event.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigDisableSockpuppetDisallowedAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a repo.config.disable_sockpuppet_disallowed + event. + """ + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigEnableAnonymousGitAccessAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a repo.config.enable_anonymous_git_access + event. + """ + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigEnableCollaboratorsOnlyAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData): + """Audit log entry for a repo.config.enable_collaborators_only event.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigEnableContributorsOnlyAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData): + """Audit log entry for a repo.config.enable_contributors_only event.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigEnableSockpuppetDisallowedAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a repo.config.enable_sockpuppet_disallowed + event. + """ + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigLockAnonymousGitAccessAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData): + """Audit log entry for a repo.config.lock_anonymous_git_access event.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepoConfigUnlockAnonymousGitAccessAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData +): + """Audit log entry for a repo.config.unlock_anonymous_git_access + event. + """ + + __schema__ = github_schema + __field_names__ = () + + +class RepoCreateAuditEntry(sgqlc.types.Type, Node, AuditEntry, RepositoryAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a repo.create event.""" + + __schema__ = github_schema + __field_names__ = ("fork_parent_name", "fork_source_name", "visibility") + fork_parent_name = sgqlc.types.Field(String, graphql_name="forkParentName") + """The name of the parent repository for this forked repository.""" + + fork_source_name = sgqlc.types.Field(String, graphql_name="forkSourceName") + """The name of the root repository for this network.""" + + visibility = sgqlc.types.Field(RepoCreateAuditEntryVisibility, graphql_name="visibility") + """The visibility of the repository""" + + +class RepoDestroyAuditEntry(sgqlc.types.Type, Node, AuditEntry, RepositoryAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a repo.destroy event.""" + + __schema__ = github_schema + __field_names__ = ("visibility",) + visibility = sgqlc.types.Field(RepoDestroyAuditEntryVisibility, graphql_name="visibility") + """The visibility of the repository""" + + +class RepoRemoveMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData): + """Audit log entry for a repo.remove_member event.""" + + __schema__ = github_schema + __field_names__ = ("visibility",) + visibility = sgqlc.types.Field(RepoRemoveMemberAuditEntryVisibility, graphql_name="visibility") + """The visibility of the repository""" + + +class RepoRemoveTopicAuditEntry( + sgqlc.types.Type, Node, AuditEntry, RepositoryAuditEntryData, OrganizationAuditEntryData, TopicAuditEntryData +): + """Audit log entry for a repo.remove_topic event.""" + + __schema__ = github_schema + __field_names__ = () + + +class Repository(sgqlc.types.Type, Node, ProjectOwner, PackageOwner, Subscribable, Starrable, UniformResourceLocatable, RepositoryInfo): + """A repository contains the content for a project.""" + + __schema__ = github_schema + __field_names__ = ( + "allow_update_branch", + "assignable_users", + "auto_merge_allowed", + "branch_protection_rules", + "code_of_conduct", + "codeowners", + "collaborators", + "commit_comments", + "contact_links", + "database_id", + "default_branch_ref", + "delete_branch_on_merge", + "deploy_keys", + "deployments", + "discussion", + "discussion_categories", + "discussions", + "disk_usage", + "environment", + "environments", + "forking_allowed", + "forks", + "funding_links", + "interaction_ability", + "is_blank_issues_enabled", + "is_disabled", + "is_empty", + "is_security_policy_enabled", + "is_user_configuration_repository", + "issue", + "issue_or_pull_request", + "issue_templates", + "issues", + "label", + "labels", + "languages", + "latest_release", + "mentionable_users", + "merge_commit_allowed", + "milestone", + "milestones", + "object", + "parent", + "pinned_discussions", + "pinned_issues", + "primary_language", + "project_next", + "projects_next", + "pull_request", + "pull_request_templates", + "pull_requests", + "rebase_merge_allowed", + "ref", + "refs", + "release", + "releases", + "repository_topics", + "security_policy_url", + "squash_merge_allowed", + "squash_pr_title_used_as_default", + "ssh_url", + "submodules", + "temp_clone_token", + "template_repository", + "viewer_can_administer", + "viewer_can_update_topics", + "viewer_default_commit_email", + "viewer_default_merge_method", + "viewer_permission", + "viewer_possible_commit_emails", + "vulnerability_alerts", + "watchers", + ) + allow_update_branch = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="allowUpdateBranch") + """Whether or not a pull request head branch that is behind its base + branch can always be updated even if it is not required to be up + to date before merging. + """ + + assignable_users = sgqlc.types.Field( + sgqlc.types.non_null(UserConnection), + graphql_name="assignableUsers", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users that can be assigned to issues in this repository. + + Arguments: + + * `query` (`String`): Filters users with query on user name and + login + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + auto_merge_allowed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="autoMergeAllowed") + """Whether or not Auto-merge can be enabled on pull requests in this + repository. + """ + + branch_protection_rules = sgqlc.types.Field( + sgqlc.types.non_null(BranchProtectionRuleConnection), + graphql_name="branchProtectionRules", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of branch protection rules for this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + code_of_conduct = sgqlc.types.Field(CodeOfConduct, graphql_name="codeOfConduct") + """Returns the code of conduct for this repository""" + + codeowners = sgqlc.types.Field( + RepositoryCodeowners, + graphql_name="codeowners", + args=sgqlc.types.ArgDict((("ref_name", sgqlc.types.Arg(String, graphql_name="refName", default=None)),)), + ) + """Information extracted from the repository's `CODEOWNERS` file. + + Arguments: + + * `ref_name` (`String`): The ref name used to return the + associated `CODEOWNERS` file. + """ + + collaborators = sgqlc.types.Field( + RepositoryCollaboratorConnection, + graphql_name="collaborators", + args=sgqlc.types.ArgDict( + ( + ("affiliation", sgqlc.types.Arg(CollaboratorAffiliation, graphql_name="affiliation", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of collaborators associated with the repository. + + Arguments: + + * `affiliation` (`CollaboratorAffiliation`): Collaborators + affiliation level with a repository. + * `query` (`String`): Filters users with query on user name and + login + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + commit_comments = sgqlc.types.Field( + sgqlc.types.non_null(CommitCommentConnection), + graphql_name="commitComments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of commit comments associated with the repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + contact_links = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(RepositoryContactLink)), graphql_name="contactLinks") + """Returns a list of contact links associated to the repository""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + default_branch_ref = sgqlc.types.Field(Ref, graphql_name="defaultBranchRef") + """The Ref associated with the repository's default branch.""" + + delete_branch_on_merge = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="deleteBranchOnMerge") + """Whether or not branches are automatically deleted when merged in + this repository. + """ + + deploy_keys = sgqlc.types.Field( + sgqlc.types.non_null(DeployKeyConnection), + graphql_name="deployKeys", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of deploy keys that are on this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + deployments = sgqlc.types.Field( + sgqlc.types.non_null(DeploymentConnection), + graphql_name="deployments", + args=sgqlc.types.ArgDict( + ( + ( + "environments", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="environments", default=None), + ), + ("order_by", sgqlc.types.Arg(DeploymentOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "ASC"})), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Deployments associated with the repository + + Arguments: + + * `environments` (`[String!]`): Environments to list deployments + for + * `order_by` (`DeploymentOrder`): Ordering options for deployments + returned from the connection. (default: `{field: CREATED_AT, + direction: ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + discussion = sgqlc.types.Field( + Discussion, + graphql_name="discussion", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Returns a single discussion from the current repository by number. + + Arguments: + + * `number` (`Int!`): The number for the discussion to be returned. + """ + + discussion_categories = sgqlc.types.Field( + sgqlc.types.non_null(DiscussionCategoryConnection), + graphql_name="discussionCategories", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("filter_by_assignable", sgqlc.types.Arg(Boolean, graphql_name="filterByAssignable", default=False)), + ) + ), + ) + """A list of discussion categories that are available in the + repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `filter_by_assignable` (`Boolean`): Filter by categories that + are assignable by the viewer. (default: `false`) + """ + + discussions = sgqlc.types.Field( + sgqlc.types.non_null(DiscussionConnection), + graphql_name="discussions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("category_id", sgqlc.types.Arg(ID, graphql_name="categoryId", default=None)), + ( + "order_by", + sgqlc.types.Arg(DiscussionOrder, graphql_name="orderBy", default={"field": "UPDATED_AT", "direction": "DESC"}), + ), + ) + ), + ) + """A list of discussions that have been opened in the repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `category_id` (`ID`): Only include discussions that belong to + the category with this ID. (default: `null`) + * `order_by` (`DiscussionOrder`): Ordering options for discussions + returned from the connection. (default: `{field: UPDATED_AT, + direction: DESC}`) + """ + + disk_usage = sgqlc.types.Field(Int, graphql_name="diskUsage") + """The number of kilobytes this repository occupies on disk.""" + + environment = sgqlc.types.Field( + Environment, + graphql_name="environment", + args=sgqlc.types.ArgDict((("name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="name", default=None)),)), + ) + """Returns a single active environment from the current repository by + name. + + Arguments: + + * `name` (`String!`): The name of the environment to be returned. + """ + + environments = sgqlc.types.Field( + sgqlc.types.non_null(EnvironmentConnection), + graphql_name="environments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of environments that are in this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + forking_allowed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="forkingAllowed") + """Whether this repository allows forks.""" + + forks = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryConnection), + graphql_name="forks", + args=sgqlc.types.ArgDict( + ( + ("privacy", sgqlc.types.Arg(RepositoryPrivacy, graphql_name="privacy", default=None)), + ("order_by", sgqlc.types.Arg(RepositoryOrder, graphql_name="orderBy", default=None)), + ("affiliations", sgqlc.types.Arg(sgqlc.types.list_of(RepositoryAffiliation), graphql_name="affiliations", default=None)), + ( + "owner_affiliations", + sgqlc.types.Arg( + sgqlc.types.list_of(RepositoryAffiliation), graphql_name="ownerAffiliations", default=("OWNER", "COLLABORATOR") + ), + ), + ("is_locked", sgqlc.types.Arg(Boolean, graphql_name="isLocked", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of direct forked repositories. + + Arguments: + + * `privacy` (`RepositoryPrivacy`): If non-null, filters + repositories according to privacy + * `order_by` (`RepositoryOrder`): Ordering options for + repositories returned from the connection + * `affiliations` (`[RepositoryAffiliation]`): Array of viewer's + affiliation options for repositories returned from the + connection. For example, OWNER will include only repositories + that the current viewer owns. + * `owner_affiliations` (`[RepositoryAffiliation]`): Array of + owner's affiliation options for repositories returned from the + connection. For example, OWNER will include only repositories + that the organization or user being viewed owns. (default: + `[OWNER, COLLABORATOR]`) + * `is_locked` (`Boolean`): If non-null, filters repositories + according to whether they have been locked + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + funding_links = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(FundingLink))), graphql_name="fundingLinks" + ) + """The funding links for this repository""" + + interaction_ability = sgqlc.types.Field(RepositoryInteractionAbility, graphql_name="interactionAbility") + """The interaction ability settings for this repository.""" + + is_blank_issues_enabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isBlankIssuesEnabled") + """Returns true if blank issue creation is allowed""" + + is_disabled = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDisabled") + """Returns whether or not this repository disabled.""" + + is_empty = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isEmpty") + """Returns whether or not this repository is empty.""" + + is_security_policy_enabled = sgqlc.types.Field(Boolean, graphql_name="isSecurityPolicyEnabled") + """Returns true if this repository has a security policy""" + + is_user_configuration_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isUserConfigurationRepository") + """Is this repository a user configuration repository?""" + + issue = sgqlc.types.Field( + Issue, + graphql_name="issue", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Returns a single issue from the current repository by number. + + Arguments: + + * `number` (`Int!`): The number for the issue to be returned. + """ + + issue_or_pull_request = sgqlc.types.Field( + "IssueOrPullRequest", + graphql_name="issueOrPullRequest", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Returns a single issue-like object from the current repository by + number. + + Arguments: + + * `number` (`Int!`): The number for the issue to be returned. + """ + + issue_templates = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(IssueTemplate)), graphql_name="issueTemplates") + """Returns a list of issue templates associated to the repository""" + + issues = sgqlc.types.Field( + sgqlc.types.non_null(IssueConnection), + graphql_name="issues", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("states", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(IssueState)), graphql_name="states", default=None)), + ("filter_by", sgqlc.types.Arg(IssueFilters, graphql_name="filterBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of issues that have been opened in the repository. + + Arguments: + + * `order_by` (`IssueOrder`): Ordering options for issues returned + from the connection. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `states` (`[IssueState!]`): A list of states to filter the + issues by. + * `filter_by` (`IssueFilters`): Filtering options for issues + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + label = sgqlc.types.Field( + Label, + graphql_name="label", + args=sgqlc.types.ArgDict((("name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="name", default=None)),)), + ) + """Returns a single label by name + + Arguments: + + * `name` (`String!`): Label name + """ + + labels = sgqlc.types.Field( + LabelConnection, + graphql_name="labels", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(LabelOrder, graphql_name="orderBy", default={"field": "CREATED_AT", "direction": "ASC"})), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ) + ), + ) + """A list of labels associated with the repository. + + Arguments: + + * `order_by` (`LabelOrder`): Ordering options for labels returned + from the connection. (default: `{field: CREATED_AT, direction: + ASC}`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `query` (`String`): If provided, searches labels by name and + description. + """ + + languages = sgqlc.types.Field( + LanguageConnection, + graphql_name="languages", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(LanguageOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """A list containing a breakdown of the language composition of the + repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`LanguageOrder`): Order for connection + """ + + latest_release = sgqlc.types.Field(Release, graphql_name="latestRelease") + """Get the latest release for the repository if one exists.""" + + mentionable_users = sgqlc.types.Field( + sgqlc.types.non_null(UserConnection), + graphql_name="mentionableUsers", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of Users that can be mentioned in the context of the + repository. + + Arguments: + + * `query` (`String`): Filters users with query on user name and + login + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + merge_commit_allowed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="mergeCommitAllowed") + """Whether or not PRs are merged with a merge commit on this + repository. + """ + + milestone = sgqlc.types.Field( + Milestone, + graphql_name="milestone", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Returns a single milestone from the current repository by number. + + Arguments: + + * `number` (`Int!`): The number for the milestone to be returned. + """ + + milestones = sgqlc.types.Field( + MilestoneConnection, + graphql_name="milestones", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("states", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(MilestoneState)), graphql_name="states", default=None)), + ("order_by", sgqlc.types.Arg(MilestoneOrder, graphql_name="orderBy", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ) + ), + ) + """A list of milestones associated with the repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `states` (`[MilestoneState!]`): Filter by the state of the + milestones. + * `order_by` (`MilestoneOrder`): Ordering options for milestones. + * `query` (`String`): Filters milestones with a query on the title + """ + + object = sgqlc.types.Field( + GitObject, + graphql_name="object", + args=sgqlc.types.ArgDict( + ( + ("oid", sgqlc.types.Arg(GitObjectID, graphql_name="oid", default=None)), + ("expression", sgqlc.types.Arg(String, graphql_name="expression", default=None)), + ) + ), + ) + """A Git object in the repository + + Arguments: + + * `oid` (`GitObjectID`): The Git object ID + * `expression` (`String`): A Git revision expression suitable for + rev-parse + """ + + parent = sgqlc.types.Field("Repository", graphql_name="parent") + """The repository parent, if this is a fork.""" + + pinned_discussions = sgqlc.types.Field( + sgqlc.types.non_null(PinnedDiscussionConnection), + graphql_name="pinnedDiscussions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of discussions that have been pinned in this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pinned_issues = sgqlc.types.Field( + PinnedIssueConnection, + graphql_name="pinnedIssues", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pinned issues for this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + primary_language = sgqlc.types.Field(Language, graphql_name="primaryLanguage") + """The primary language of the repository's code.""" + + project_next = sgqlc.types.Field( + ProjectNext, + graphql_name="projectNext", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Finds and returns the Project (beta) according to the provided + Project (beta) number. + + Arguments: + + * `number` (`Int!`): The ProjectNext number. + """ + + projects_next = sgqlc.types.Field( + sgqlc.types.non_null(ProjectNextConnection), + graphql_name="projectsNext", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("sort_by", sgqlc.types.Arg(ProjectNextOrderField, graphql_name="sortBy", default="TITLE")), + ) + ), + ) + """List of projects (beta) linked to this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `query` (`String`): A project (beta) to search for linked to the + repo. + * `sort_by` (`ProjectNextOrderField`): How to order the returned + project (beta) objects. (default: `TITLE`) + """ + + pull_request = sgqlc.types.Field( + PullRequest, + graphql_name="pullRequest", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Returns a single pull request from the current repository by + number. + + Arguments: + + * `number` (`Int!`): The number for the pull request to be + returned. + """ + + pull_request_templates = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(PullRequestTemplate)), graphql_name="pullRequestTemplates" + ) + """Returns a list of pull request templates associated to the + repository + """ + + pull_requests = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestConnection), + graphql_name="pullRequests", + args=sgqlc.types.ArgDict( + ( + ( + "states", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PullRequestState)), graphql_name="states", default=None), + ), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("head_ref_name", sgqlc.types.Arg(String, graphql_name="headRefName", default=None)), + ("base_ref_name", sgqlc.types.Arg(String, graphql_name="baseRefName", default=None)), + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pull requests that have been opened in the repository. + + Arguments: + + * `states` (`[PullRequestState!]`): A list of states to filter the + pull requests by. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `head_ref_name` (`String`): The head ref name to filter the pull + requests by. + * `base_ref_name` (`String`): The base ref name to filter the pull + requests by. + * `order_by` (`IssueOrder`): Ordering options for pull requests + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + rebase_merge_allowed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="rebaseMergeAllowed") + """Whether or not rebase-merging is enabled on this repository.""" + + ref = sgqlc.types.Field( + Ref, + graphql_name="ref", + args=sgqlc.types.ArgDict( + (("qualified_name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="qualifiedName", default=None)),) + ), + ) + """Fetch a given ref from the repository + + Arguments: + + * `qualified_name` (`String!`): The ref to retrieve. Fully + qualified matches are checked in order (`refs/heads/master`) + before falling back onto checks for short name matches + (`master`). + """ + + refs = sgqlc.types.Field( + RefConnection, + graphql_name="refs", + args=sgqlc.types.ArgDict( + ( + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("ref_prefix", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="refPrefix", default=None)), + ("direction", sgqlc.types.Arg(OrderDirection, graphql_name="direction", default=None)), + ("order_by", sgqlc.types.Arg(RefOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """Fetch a list of refs from the repository + + Arguments: + + * `query` (`String`): Filters refs with query on name + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `ref_prefix` (`String!`): A ref name prefix like `refs/heads/`, + `refs/tags/`, etc. + * `direction` (`OrderDirection`): DEPRECATED: use orderBy. The + ordering direction. + * `order_by` (`RefOrder`): Ordering options for refs returned from + the connection. + """ + + release = sgqlc.types.Field( + Release, + graphql_name="release", + args=sgqlc.types.ArgDict((("tag_name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="tagName", default=None)),)), + ) + """Lookup a single release given various criteria. + + Arguments: + + * `tag_name` (`String!`): The name of the Tag the Release was + created from + """ + + releases = sgqlc.types.Field( + sgqlc.types.non_null(ReleaseConnection), + graphql_name="releases", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(ReleaseOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """List of releases which are dependent on this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`ReleaseOrder`): Order for connection + """ + + repository_topics = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryTopicConnection), + graphql_name="repositoryTopics", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of applied repository-topic associations for this + repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + security_policy_url = sgqlc.types.Field(URI, graphql_name="securityPolicyUrl") + """The security policy URL.""" + + squash_merge_allowed = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="squashMergeAllowed") + """Whether or not squash-merging is enabled on this repository.""" + + squash_pr_title_used_as_default = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="squashPrTitleUsedAsDefault") + """Whether a squash merge commit can use the pull request title as + default. + """ + + ssh_url = sgqlc.types.Field(sgqlc.types.non_null(GitSSHRemote), graphql_name="sshUrl") + """The SSH URL to clone this repository""" + + submodules = sgqlc.types.Field( + sgqlc.types.non_null(SubmoduleConnection), + graphql_name="submodules", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Returns a list of all submodules in this repository parsed from + the .gitmodules file as of the default branch's HEAD commit. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + temp_clone_token = sgqlc.types.Field(String, graphql_name="tempCloneToken") + """Temporary authentication token for cloning this repository.""" + + template_repository = sgqlc.types.Field("Repository", graphql_name="templateRepository") + """The repository from which this repository was generated, if any.""" + + viewer_can_administer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanAdminister") + """Indicates whether the viewer has admin permissions on this + repository. + """ + + viewer_can_update_topics = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanUpdateTopics") + """Indicates whether the viewer can update the topics of this + repository. + """ + + viewer_default_commit_email = sgqlc.types.Field(String, graphql_name="viewerDefaultCommitEmail") + """The last commit email for the viewer.""" + + viewer_default_merge_method = sgqlc.types.Field(sgqlc.types.non_null(PullRequestMergeMethod), graphql_name="viewerDefaultMergeMethod") + """The last used merge method by the viewer or the default for the + repository. + """ + + viewer_permission = sgqlc.types.Field(RepositoryPermission, graphql_name="viewerPermission") + """The users permission level on the repository. Will return null if + authenticated as an GitHub App. + """ + + viewer_possible_commit_emails = sgqlc.types.Field( + sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="viewerPossibleCommitEmails" + ) + """A list of emails this viewer can commit with.""" + + vulnerability_alerts = sgqlc.types.Field( + RepositoryVulnerabilityAlertConnection, + graphql_name="vulnerabilityAlerts", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "states", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(RepositoryVulnerabilityAlertState)), graphql_name="states", default=None + ), + ), + ) + ), + ) + """A list of vulnerability alerts that are on this repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `states` (`[RepositoryVulnerabilityAlertState!]`): Filter by the + state of the alert + """ + + watchers = sgqlc.types.Field( + sgqlc.types.non_null(UserConnection), + graphql_name="watchers", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users watching the repository. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class RepositoryInvitation(sgqlc.types.Type, Node): + """An invitation for a user to be added to a repository.""" + + __schema__ = github_schema + __field_names__ = ("email", "invitee", "inviter", "permalink", "permission", "repository") + email = sgqlc.types.Field(String, graphql_name="email") + """The email address that received the invitation.""" + + invitee = sgqlc.types.Field("User", graphql_name="invitee") + """The user who received the invitation.""" + + inviter = sgqlc.types.Field(sgqlc.types.non_null("User"), graphql_name="inviter") + """The user who created the invitation.""" + + permalink = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="permalink") + """The permalink for this repository invitation.""" + + permission = sgqlc.types.Field(sgqlc.types.non_null(RepositoryPermission), graphql_name="permission") + """The permission granted on this repository by this invitation.""" + + repository = sgqlc.types.Field(RepositoryInfo, graphql_name="repository") + """The Repository the user is invited to.""" + + +class RepositoryMigration(sgqlc.types.Type, Node, Migration): + """An Octoshift repository migration.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepositoryTopic(sgqlc.types.Type, Node, UniformResourceLocatable): + """A repository-topic connects a repository to a topic.""" + + __schema__ = github_schema + __field_names__ = ("topic",) + topic = sgqlc.types.Field(sgqlc.types.non_null("Topic"), graphql_name="topic") + """The topic.""" + + +class RepositoryVisibilityChangeDisableAuditEntry(sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a repository_visibility_change.disable event.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepositoryVisibilityChangeEnableAuditEntry(sgqlc.types.Type, Node, AuditEntry, EnterpriseAuditEntryData, OrganizationAuditEntryData): + """Audit log entry for a repository_visibility_change.enable event.""" + + __schema__ = github_schema + __field_names__ = () + + +class RepositoryVulnerabilityAlert(sgqlc.types.Type, Node, RepositoryNode): + """A Dependabot alert for a repository with a dependency affected by + a security vulnerability. + """ + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "dependabot_update", + "dismiss_reason", + "dismissed_at", + "dismisser", + "fix_reason", + "fixed_at", + "number", + "security_advisory", + "security_vulnerability", + "state", + "vulnerable_manifest_filename", + "vulnerable_manifest_path", + "vulnerable_requirements", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """When was the alert created?""" + + dependabot_update = sgqlc.types.Field(DependabotUpdate, graphql_name="dependabotUpdate") + """The associated Dependabot update""" + + dismiss_reason = sgqlc.types.Field(String, graphql_name="dismissReason") + """The reason the alert was dismissed""" + + dismissed_at = sgqlc.types.Field(DateTime, graphql_name="dismissedAt") + """When was the alert dismissed?""" + + dismisser = sgqlc.types.Field("User", graphql_name="dismisser") + """The user who dismissed the alert""" + + fix_reason = sgqlc.types.Field(String, graphql_name="fixReason") + """The reason the alert was marked as fixed.""" + + fixed_at = sgqlc.types.Field(DateTime, graphql_name="fixedAt") + """When was the alert fixed?""" + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """Identifies the alert number.""" + + security_advisory = sgqlc.types.Field("SecurityAdvisory", graphql_name="securityAdvisory") + """The associated security advisory""" + + security_vulnerability = sgqlc.types.Field(SecurityVulnerability, graphql_name="securityVulnerability") + """The associated security vulnerability""" + + state = sgqlc.types.Field(sgqlc.types.non_null(RepositoryVulnerabilityAlertState), graphql_name="state") + """Identifies the state of the alert.""" + + vulnerable_manifest_filename = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="vulnerableManifestFilename") + """The vulnerable manifest filename""" + + vulnerable_manifest_path = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="vulnerableManifestPath") + """The vulnerable manifest path""" + + vulnerable_requirements = sgqlc.types.Field(String, graphql_name="vulnerableRequirements") + """The vulnerable requirements""" + + +class RestrictedContribution(sgqlc.types.Type, Contribution): + """Represents a private contribution a user made on GitHub.""" + + __schema__ = github_schema + __field_names__ = () + + +class ReviewDismissalAllowance(sgqlc.types.Type, Node): + """A user, team, or app who has the ability to dismiss a review on a + protected branch. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "branch_protection_rule") + actor = sgqlc.types.Field("ReviewDismissalAllowanceActor", graphql_name="actor") + """The actor that can dismiss.""" + + branch_protection_rule = sgqlc.types.Field(BranchProtectionRule, graphql_name="branchProtectionRule") + """Identifies the branch protection rule associated with the allowed + user, team, or app. + """ + + +class ReviewDismissedEvent(sgqlc.types.Type, Node, UniformResourceLocatable): + """Represents a 'review_dismissed' event on a given issue or pull + request. + """ + + __schema__ = github_schema + __field_names__ = ( + "actor", + "created_at", + "database_id", + "dismissal_message", + "dismissal_message_html", + "previous_review_state", + "pull_request", + "pull_request_commit", + "review", + ) + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + dismissal_message = sgqlc.types.Field(String, graphql_name="dismissalMessage") + """Identifies the optional message associated with the + 'review_dismissed' event. + """ + + dismissal_message_html = sgqlc.types.Field(String, graphql_name="dismissalMessageHTML") + """Identifies the optional message associated with the event, + rendered to HTML. + """ + + previous_review_state = sgqlc.types.Field(sgqlc.types.non_null(PullRequestReviewState), graphql_name="previousReviewState") + """Identifies the previous state of the review with the + 'review_dismissed' event. + """ + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + pull_request_commit = sgqlc.types.Field(PullRequestCommit, graphql_name="pullRequestCommit") + """Identifies the commit which caused the review to become stale.""" + + review = sgqlc.types.Field(PullRequestReview, graphql_name="review") + """Identifies the review associated with the 'review_dismissed' + event. + """ + + +class ReviewRequest(sgqlc.types.Type, Node): + """A request for a user to review a pull request.""" + + __schema__ = github_schema + __field_names__ = ("as_code_owner", "database_id", "pull_request", "requested_reviewer") + as_code_owner = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="asCodeOwner") + """Whether this request was created for a code owner""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """Identifies the pull request associated with this review request.""" + + requested_reviewer = sgqlc.types.Field("RequestedReviewer", graphql_name="requestedReviewer") + """The reviewer that is requested.""" + + +class ReviewRequestRemovedEvent(sgqlc.types.Type, Node): + """Represents an 'review_request_removed' event on a given pull + request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "pull_request", "requested_reviewer") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + requested_reviewer = sgqlc.types.Field("RequestedReviewer", graphql_name="requestedReviewer") + """Identifies the reviewer whose review request was removed.""" + + +class ReviewRequestedEvent(sgqlc.types.Type, Node): + """Represents an 'review_requested' event on a given pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "pull_request", "requested_reviewer") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + pull_request = sgqlc.types.Field(sgqlc.types.non_null(PullRequest), graphql_name="pullRequest") + """PullRequest referenced by event.""" + + requested_reviewer = sgqlc.types.Field("RequestedReviewer", graphql_name="requestedReviewer") + """Identifies the reviewer whose review was requested.""" + + +class ReviewStatusHovercardContext(sgqlc.types.Type, HovercardContext): + """A hovercard context with a message describing the current code + review state of the pull request. + """ + + __schema__ = github_schema + __field_names__ = ("review_decision",) + review_decision = sgqlc.types.Field(PullRequestReviewDecision, graphql_name="reviewDecision") + """The current status of the pull request with respect to code + review. + """ + + +class SavedReply(sgqlc.types.Type, Node): + """A Saved Reply is text a user can use to reply quickly.""" + + __schema__ = github_schema + __field_names__ = ("body", "body_html", "database_id", "title", "user") + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The body of the saved reply.""" + + body_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="bodyHTML") + """The saved reply body rendered to HTML.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the saved reply.""" + + user = sgqlc.types.Field(Actor, graphql_name="user") + """The user that saved this reply.""" + + +class SecurityAdvisory(sgqlc.types.Type, Node): + """A GitHub Security Advisory""" + + __schema__ = github_schema + __field_names__ = ( + "classification", + "cvss", + "cwes", + "database_id", + "description", + "ghsa_id", + "identifiers", + "notifications_permalink", + "origin", + "permalink", + "published_at", + "references", + "severity", + "summary", + "updated_at", + "vulnerabilities", + "withdrawn_at", + ) + classification = sgqlc.types.Field(sgqlc.types.non_null(SecurityAdvisoryClassification), graphql_name="classification") + """The classification of the advisory""" + + cvss = sgqlc.types.Field(sgqlc.types.non_null(CVSS), graphql_name="cvss") + """The CVSS associated with this advisory""" + + cwes = sgqlc.types.Field( + sgqlc.types.non_null(CWEConnection), + graphql_name="cwes", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """CWEs associated with this Advisory + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description") + """This is a long plaintext description of the advisory""" + + ghsa_id = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="ghsaId") + """The GitHub Security Advisory ID""" + + identifiers = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(SecurityAdvisoryIdentifier))), graphql_name="identifiers" + ) + """A list of identifiers for this advisory""" + + notifications_permalink = sgqlc.types.Field(URI, graphql_name="notificationsPermalink") + """The permalink for the advisory's dependabot alerts page""" + + origin = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="origin") + """The organization that originated the advisory""" + + permalink = sgqlc.types.Field(URI, graphql_name="permalink") + """The permalink for the advisory""" + + published_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="publishedAt") + """When the advisory was published""" + + references = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(SecurityAdvisoryReference))), graphql_name="references" + ) + """A list of references for this advisory""" + + severity = sgqlc.types.Field(sgqlc.types.non_null(SecurityAdvisorySeverity), graphql_name="severity") + """The severity of the advisory""" + + summary = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="summary") + """A short plaintext summary of the advisory""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """When the advisory was last updated""" + + vulnerabilities = sgqlc.types.Field( + sgqlc.types.non_null(SecurityVulnerabilityConnection), + graphql_name="vulnerabilities", + args=sgqlc.types.ArgDict( + ( + ( + "order_by", + sgqlc.types.Arg( + SecurityVulnerabilityOrder, graphql_name="orderBy", default={"field": "UPDATED_AT", "direction": "DESC"} + ), + ), + ("ecosystem", sgqlc.types.Arg(SecurityAdvisoryEcosystem, graphql_name="ecosystem", default=None)), + ("package", sgqlc.types.Arg(String, graphql_name="package", default=None)), + ( + "severities", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(SecurityAdvisorySeverity)), graphql_name="severities", default=None + ), + ), + ( + "classifications", + sgqlc.types.Arg( + sgqlc.types.list_of(sgqlc.types.non_null(SecurityAdvisoryClassification)), + graphql_name="classifications", + default=None, + ), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """Vulnerabilities associated with this Advisory + + Arguments: + + * `order_by` (`SecurityVulnerabilityOrder`): Ordering options for + the returned topics. (default: `{field: UPDATED_AT, direction: + DESC}`) + * `ecosystem` (`SecurityAdvisoryEcosystem`): An ecosystem to + filter vulnerabilities by. + * `package` (`String`): A package name to filter vulnerabilities + by. + * `severities` (`[SecurityAdvisorySeverity!]`): A list of + severities to filter vulnerabilities by. + * `classifications` (`[SecurityAdvisoryClassification!]`): A list + of advisory classifications to filter vulnerabilities by. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + withdrawn_at = sgqlc.types.Field(DateTime, graphql_name="withdrawnAt") + """When the advisory was withdrawn, if it has been withdrawn""" + + +class SmimeSignature(sgqlc.types.Type, GitSignature): + """Represents an S/MIME signature on a Commit or Tag.""" + + __schema__ = github_schema + __field_names__ = () + + +class SponsorsActivity(sgqlc.types.Type, Node): + """An event related to sponsorship activity.""" + + __schema__ = github_schema + __field_names__ = ("action", "previous_sponsors_tier", "sponsor", "sponsorable", "sponsors_tier", "timestamp") + action = sgqlc.types.Field(sgqlc.types.non_null(SponsorsActivityAction), graphql_name="action") + """What action this activity indicates took place.""" + + previous_sponsors_tier = sgqlc.types.Field("SponsorsTier", graphql_name="previousSponsorsTier") + """The tier that the sponsorship used to use, for tier change events.""" + + sponsor = sgqlc.types.Field("Sponsor", graphql_name="sponsor") + """The user or organization who triggered this activity and was/is + sponsoring the sponsorable. + """ + + sponsorable = sgqlc.types.Field(sgqlc.types.non_null(Sponsorable), graphql_name="sponsorable") + """The user or organization that is being sponsored, the maintainer.""" + + sponsors_tier = sgqlc.types.Field("SponsorsTier", graphql_name="sponsorsTier") + """The associated sponsorship tier.""" + + timestamp = sgqlc.types.Field(DateTime, graphql_name="timestamp") + """The timestamp of this event.""" + + +class SponsorsListing(sgqlc.types.Type, Node): + """A GitHub Sponsors listing.""" + + __schema__ = github_schema + __field_names__ = ( + "active_goal", + "created_at", + "full_description", + "full_description_html", + "is_public", + "name", + "next_payout_date", + "short_description", + "slug", + "sponsorable", + "tiers", + ) + active_goal = sgqlc.types.Field(SponsorsGoal, graphql_name="activeGoal") + """The current goal the maintainer is trying to reach with GitHub + Sponsors, if any. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + full_description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="fullDescription") + """The full description of the listing.""" + + full_description_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="fullDescriptionHTML") + """The full description of the listing rendered to HTML.""" + + is_public = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPublic") + """Whether this listing is publicly visible.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The listing's full name.""" + + next_payout_date = sgqlc.types.Field(Date, graphql_name="nextPayoutDate") + """A future date on which this listing is eligible to receive a + payout. + """ + + short_description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="shortDescription") + """The short description of the listing.""" + + slug = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="slug") + """The short name of the listing.""" + + sponsorable = sgqlc.types.Field(sgqlc.types.non_null(Sponsorable), graphql_name="sponsorable") + """The entity this listing represents who can be sponsored on GitHub + Sponsors. + """ + + tiers = sgqlc.types.Field( + SponsorsTierConnection, + graphql_name="tiers", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg( + SponsorsTierOrder, graphql_name="orderBy", default={"field": "MONTHLY_PRICE_IN_CENTS", "direction": "ASC"} + ), + ), + ) + ), + ) + """The published tiers for this GitHub Sponsors listing. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`SponsorsTierOrder`): Ordering options for Sponsors + tiers returned from the connection. (default: `{field: + MONTHLY_PRICE_IN_CENTS, direction: ASC}`) + """ + + +class SponsorsTier(sgqlc.types.Type, Node): + """A GitHub Sponsors tier associated with a GitHub Sponsors listing.""" + + __schema__ = github_schema + __field_names__ = ( + "admin_info", + "closest_lesser_value_tier", + "created_at", + "description", + "description_html", + "is_custom_amount", + "is_one_time", + "monthly_price_in_cents", + "monthly_price_in_dollars", + "name", + "sponsors_listing", + "updated_at", + ) + admin_info = sgqlc.types.Field(SponsorsTierAdminInfo, graphql_name="adminInfo") + """SponsorsTier information only visible to users that can administer + the associated Sponsors listing. + """ + + closest_lesser_value_tier = sgqlc.types.Field("SponsorsTier", graphql_name="closestLesserValueTier") + """Get a different tier for this tier's maintainer that is at the + same frequency as this tier but with an equal or lesser cost. + Returns the published tier with the monthly price closest to this + tier's without going over. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + description = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="description") + """The description of the tier.""" + + description_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="descriptionHTML") + """The tier description rendered to HTML""" + + is_custom_amount = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCustomAmount") + """Whether this tier was chosen at checkout time by the sponsor + rather than defined ahead of time by the maintainer who manages + the Sponsors listing. + """ + + is_one_time = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isOneTime") + """Whether this tier is only for use with one-time sponsorships.""" + + monthly_price_in_cents = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="monthlyPriceInCents") + """How much this tier costs per month in cents.""" + + monthly_price_in_dollars = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="monthlyPriceInDollars") + """How much this tier costs per month in USD.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the tier.""" + + sponsors_listing = sgqlc.types.Field(sgqlc.types.non_null(SponsorsListing), graphql_name="sponsorsListing") + """The sponsors listing that this tier belongs to.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class Sponsorship(sgqlc.types.Type, Node): + """A sponsorship relationship between a sponsor and a maintainer""" + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "is_one_time_payment", + "is_sponsor_opted_into_email", + "privacy_level", + "sponsor_entity", + "sponsorable", + "tier", + "tier_selected_at", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + is_one_time_payment = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isOneTimePayment") + """Whether this sponsorship represents a one-time payment versus a + recurring sponsorship. + """ + + is_sponsor_opted_into_email = sgqlc.types.Field(Boolean, graphql_name="isSponsorOptedIntoEmail") + """Check if the sponsor has chosen to receive sponsorship update + emails sent from the sponsorable. Only returns a non-null value + when the viewer has permission to know this. + """ + + privacy_level = sgqlc.types.Field(sgqlc.types.non_null(SponsorshipPrivacy), graphql_name="privacyLevel") + """The privacy level for this sponsorship.""" + + sponsor_entity = sgqlc.types.Field("Sponsor", graphql_name="sponsorEntity") + """The user or organization that is sponsoring, if you have + permission to view them. + """ + + sponsorable = sgqlc.types.Field(sgqlc.types.non_null(Sponsorable), graphql_name="sponsorable") + """The entity that is being sponsored""" + + tier = sgqlc.types.Field(SponsorsTier, graphql_name="tier") + """The associated sponsorship tier""" + + tier_selected_at = sgqlc.types.Field(DateTime, graphql_name="tierSelectedAt") + """Identifies the date and time when the current tier was chosen for + this sponsorship. + """ + + +class SponsorshipNewsletter(sgqlc.types.Type, Node): + """An update sent to sponsors of a user or organization on GitHub + Sponsors. + """ + + __schema__ = github_schema + __field_names__ = ("body", "created_at", "is_published", "sponsorable", "subject", "updated_at") + body = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="body") + """The contents of the newsletter, the message the sponsorable wanted + to give. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + is_published = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPublished") + """Indicates if the newsletter has been made available to sponsors.""" + + sponsorable = sgqlc.types.Field(sgqlc.types.non_null(Sponsorable), graphql_name="sponsorable") + """The user or organization this newsletter is from.""" + + subject = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="subject") + """The subject of the newsletter, what it's about.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class Status(sgqlc.types.Type, Node): + """Represents a commit status.""" + + __schema__ = github_schema + __field_names__ = ("combined_contexts", "commit", "context", "contexts", "state") + combined_contexts = sgqlc.types.Field( + sgqlc.types.non_null(StatusCheckRollupContextConnection), + graphql_name="combinedContexts", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of status contexts and check runs for this commit. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """The commit this status is attached to.""" + + context = sgqlc.types.Field( + "StatusContext", + graphql_name="context", + args=sgqlc.types.ArgDict((("name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="name", default=None)),)), + ) + """Looks up an individual status context by context name. + + Arguments: + + * `name` (`String!`): The context name. + """ + + contexts = sgqlc.types.Field(sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("StatusContext"))), graphql_name="contexts") + """The individual status contexts for this commit.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(StatusState), graphql_name="state") + """The combined commit status.""" + + +class StatusCheckRollup(sgqlc.types.Type, Node): + """Represents the rollup for both the check runs and status for a + commit. + """ + + __schema__ = github_schema + __field_names__ = ("commit", "contexts", "state") + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """The commit the status and check runs are attached to.""" + + contexts = sgqlc.types.Field( + sgqlc.types.non_null(StatusCheckRollupContextConnection), + graphql_name="contexts", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of status contexts and check runs for this commit. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + state = sgqlc.types.Field(sgqlc.types.non_null(StatusState), graphql_name="state") + """The combined status for the commit.""" + + +class StatusContext(sgqlc.types.Type, RequirableByPullRequest, Node): + """Represents an individual commit status context""" + + __schema__ = github_schema + __field_names__ = ("avatar_url", "commit", "context", "created_at", "creator", "description", "state", "target_url") + avatar_url = sgqlc.types.Field( + URI, graphql_name="avatarUrl", args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=40)),)) + ) + """The avatar of the OAuth application or the user that created the + status + + Arguments: + + * `size` (`Int`): The size of the resulting square image. + (default: `40`) + """ + + commit = sgqlc.types.Field(Commit, graphql_name="commit") + """This commit this status context is attached to.""" + + context = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="context") + """The name of this status context.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + creator = sgqlc.types.Field(Actor, graphql_name="creator") + """The actor who created this status context.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The description for this status context.""" + + state = sgqlc.types.Field(sgqlc.types.non_null(StatusState), graphql_name="state") + """The state of this status context.""" + + target_url = sgqlc.types.Field(URI, graphql_name="targetUrl") + """The URL for this status context.""" + + +class SubscribedEvent(sgqlc.types.Type, Node): + """Represents a 'subscribed' event on a given `Subscribable`.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "subscribable") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + subscribable = sgqlc.types.Field(sgqlc.types.non_null(Subscribable), graphql_name="subscribable") + """Object referenced by event.""" + + +class Tag(sgqlc.types.Type, Node, GitObject): + """Represents a Git tag.""" + + __schema__ = github_schema + __field_names__ = ("message", "name", "tagger", "target") + message = sgqlc.types.Field(String, graphql_name="message") + """The Git tag message.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The Git tag name.""" + + tagger = sgqlc.types.Field(GitActor, graphql_name="tagger") + """Details about the tag author.""" + + target = sgqlc.types.Field(sgqlc.types.non_null(GitObject), graphql_name="target") + """The Git object the tag points to.""" + + +class Team(sgqlc.types.Type, Node, Subscribable, MemberStatusable): + """A team of users in an organization.""" + + __schema__ = github_schema + __field_names__ = ( + "ancestors", + "avatar_url", + "child_teams", + "combined_slug", + "created_at", + "database_id", + "description", + "discussion", + "discussions", + "discussions_resource_path", + "discussions_url", + "edit_team_resource_path", + "edit_team_url", + "invitations", + "members", + "members_resource_path", + "members_url", + "name", + "new_team_resource_path", + "new_team_url", + "organization", + "parent_team", + "privacy", + "repositories", + "repositories_resource_path", + "repositories_url", + "resource_path", + "slug", + "teams_resource_path", + "teams_url", + "updated_at", + "url", + "viewer_can_administer", + ) + ancestors = sgqlc.types.Field( + sgqlc.types.non_null(TeamConnection), + graphql_name="ancestors", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of teams that are ancestors of this team. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + avatar_url = sgqlc.types.Field( + URI, graphql_name="avatarUrl", args=sgqlc.types.ArgDict((("size", sgqlc.types.Arg(Int, graphql_name="size", default=400)),)) + ) + """A URL pointing to the team's avatar. + + Arguments: + + * `size` (`Int`): The size in pixels of the resulting square + image. (default: `400`) + """ + + child_teams = sgqlc.types.Field( + sgqlc.types.non_null(TeamConnection), + graphql_name="childTeams", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(TeamOrder, graphql_name="orderBy", default=None)), + ( + "user_logins", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="userLogins", default=None), + ), + ("immediate_only", sgqlc.types.Arg(Boolean, graphql_name="immediateOnly", default=True)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """List of child teams belonging to this team + + Arguments: + + * `order_by` (`TeamOrder`): Order for connection + * `user_logins` (`[String!]`): User logins to filter by + * `immediate_only` (`Boolean`): Whether to list immediate child + teams or all descendant child teams. (default: `true`) + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + combined_slug = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="combinedSlug") + """The slug corresponding to the organization and team.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + description = sgqlc.types.Field(String, graphql_name="description") + """The description of the team.""" + + discussion = sgqlc.types.Field( + "TeamDiscussion", + graphql_name="discussion", + args=sgqlc.types.ArgDict((("number", sgqlc.types.Arg(sgqlc.types.non_null(Int), graphql_name="number", default=None)),)), + ) + """Find a team discussion by its number. + + Arguments: + + * `number` (`Int!`): The sequence number of the discussion to + find. + """ + + discussions = sgqlc.types.Field( + sgqlc.types.non_null(TeamDiscussionConnection), + graphql_name="discussions", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("is_pinned", sgqlc.types.Arg(Boolean, graphql_name="isPinned", default=None)), + ("order_by", sgqlc.types.Arg(TeamDiscussionOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """A list of team discussions. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `is_pinned` (`Boolean`): If provided, filters discussions + according to whether or not they are pinned. + * `order_by` (`TeamDiscussionOrder`): Order for connection + """ + + discussions_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="discussionsResourcePath") + """The HTTP path for team discussions""" + + discussions_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="discussionsUrl") + """The HTTP URL for team discussions""" + + edit_team_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="editTeamResourcePath") + """The HTTP path for editing this team""" + + edit_team_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="editTeamUrl") + """The HTTP URL for editing this team""" + + invitations = sgqlc.types.Field( + OrganizationInvitationConnection, + graphql_name="invitations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pending invitations for users to this team + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + members = sgqlc.types.Field( + sgqlc.types.non_null(TeamMemberConnection), + graphql_name="members", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("membership", sgqlc.types.Arg(TeamMembershipType, graphql_name="membership", default="ALL")), + ("role", sgqlc.types.Arg(TeamMemberRole, graphql_name="role", default=None)), + ("order_by", sgqlc.types.Arg(TeamMemberOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """A list of users who are members of this team. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `query` (`String`): The search string to look for. + * `membership` (`TeamMembershipType`): Filter by membership type + (default: `ALL`) + * `role` (`TeamMemberRole`): Filter by team member role + * `order_by` (`TeamMemberOrder`): Order for the connection. + """ + + members_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="membersResourcePath") + """The HTTP path for the team' members""" + + members_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="membersUrl") + """The HTTP URL for the team' members""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the team.""" + + new_team_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="newTeamResourcePath") + """The HTTP path creating a new team""" + + new_team_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="newTeamUrl") + """The HTTP URL creating a new team""" + + organization = sgqlc.types.Field(sgqlc.types.non_null(Organization), graphql_name="organization") + """The organization that owns this team.""" + + parent_team = sgqlc.types.Field("Team", graphql_name="parentTeam") + """The parent team of the team.""" + + privacy = sgqlc.types.Field(sgqlc.types.non_null(TeamPrivacy), graphql_name="privacy") + """The level of privacy the team has.""" + + repositories = sgqlc.types.Field( + sgqlc.types.non_null(TeamRepositoryConnection), + graphql_name="repositories", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("query", sgqlc.types.Arg(String, graphql_name="query", default=None)), + ("order_by", sgqlc.types.Arg(TeamRepositoryOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """A list of repositories this team has access to. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `query` (`String`): The search string to look for. + * `order_by` (`TeamRepositoryOrder`): Order for the connection. + """ + + repositories_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="repositoriesResourcePath") + """The HTTP path for this team's repositories""" + + repositories_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="repositoriesUrl") + """The HTTP URL for this team's repositories""" + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this team""" + + slug = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="slug") + """The slug corresponding to the team.""" + + teams_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="teamsResourcePath") + """The HTTP path for this team's teams""" + + teams_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="teamsUrl") + """The HTTP URL for this team's teams""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this team""" + + viewer_can_administer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanAdminister") + """Team is adminable by the viewer.""" + + +class TeamAddMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, TeamAuditEntryData): + """Audit log entry for a team.add_member event.""" + + __schema__ = github_schema + __field_names__ = ("is_ldap_mapped",) + is_ldap_mapped = sgqlc.types.Field(Boolean, graphql_name="isLdapMapped") + """Whether the team was mapped to an LDAP Group.""" + + +class TeamAddRepositoryAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData, TeamAuditEntryData +): + """Audit log entry for a team.add_repository event.""" + + __schema__ = github_schema + __field_names__ = ("is_ldap_mapped",) + is_ldap_mapped = sgqlc.types.Field(Boolean, graphql_name="isLdapMapped") + """Whether the team was mapped to an LDAP Group.""" + + +class TeamChangeParentTeamAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, TeamAuditEntryData): + """Audit log entry for a team.change_parent_team event.""" + + __schema__ = github_schema + __field_names__ = ( + "is_ldap_mapped", + "parent_team", + "parent_team_name", + "parent_team_name_was", + "parent_team_resource_path", + "parent_team_url", + "parent_team_was", + "parent_team_was_resource_path", + "parent_team_was_url", + ) + is_ldap_mapped = sgqlc.types.Field(Boolean, graphql_name="isLdapMapped") + """Whether the team was mapped to an LDAP Group.""" + + parent_team = sgqlc.types.Field(Team, graphql_name="parentTeam") + """The new parent team.""" + + parent_team_name = sgqlc.types.Field(String, graphql_name="parentTeamName") + """The name of the new parent team""" + + parent_team_name_was = sgqlc.types.Field(String, graphql_name="parentTeamNameWas") + """The name of the former parent team""" + + parent_team_resource_path = sgqlc.types.Field(URI, graphql_name="parentTeamResourcePath") + """The HTTP path for the parent team""" + + parent_team_url = sgqlc.types.Field(URI, graphql_name="parentTeamUrl") + """The HTTP URL for the parent team""" + + parent_team_was = sgqlc.types.Field(Team, graphql_name="parentTeamWas") + """The former parent team.""" + + parent_team_was_resource_path = sgqlc.types.Field(URI, graphql_name="parentTeamWasResourcePath") + """The HTTP path for the previous parent team""" + + parent_team_was_url = sgqlc.types.Field(URI, graphql_name="parentTeamWasUrl") + """The HTTP URL for the previous parent team""" + + +class TeamDiscussion( + sgqlc.types.Type, Node, Comment, Deletable, Reactable, Subscribable, UniformResourceLocatable, Updatable, UpdatableComment +): + """A team discussion.""" + + __schema__ = github_schema + __field_names__ = ( + "body_version", + "comments", + "comments_resource_path", + "comments_url", + "is_pinned", + "is_private", + "number", + "team", + "title", + "viewer_can_pin", + ) + body_version = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="bodyVersion") + """Identifies the discussion body hash.""" + + comments = sgqlc.types.Field( + sgqlc.types.non_null(TeamDiscussionCommentConnection), + graphql_name="comments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(TeamDiscussionCommentOrder, graphql_name="orderBy", default=None)), + ("from_comment", sgqlc.types.Arg(Int, graphql_name="fromComment", default=None)), + ) + ), + ) + """A list of comments on this discussion. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`TeamDiscussionCommentOrder`): Order for connection + * `from_comment` (`Int`): When provided, filters the connection + such that results begin with the comment with this number. + """ + + comments_resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="commentsResourcePath") + """The HTTP path for discussion comments""" + + comments_url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="commentsUrl") + """The HTTP URL for discussion comments""" + + is_pinned = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPinned") + """Whether or not the discussion is pinned.""" + + is_private = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isPrivate") + """Whether or not the discussion is only visible to team members and + org admins. + """ + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """Identifies the discussion within its team.""" + + team = sgqlc.types.Field(sgqlc.types.non_null(Team), graphql_name="team") + """The team that defines the context of this discussion.""" + + title = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="title") + """The title of the discussion""" + + viewer_can_pin = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanPin") + """Whether or not the current viewer can pin this discussion.""" + + +class TeamDiscussionComment(sgqlc.types.Type, Node, Comment, Deletable, Reactable, UniformResourceLocatable, Updatable, UpdatableComment): + """A comment on a team discussion.""" + + __schema__ = github_schema + __field_names__ = ("body_version", "discussion", "number") + body_version = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="bodyVersion") + """The current version of the body content.""" + + discussion = sgqlc.types.Field(sgqlc.types.non_null(TeamDiscussion), graphql_name="discussion") + """The discussion this comment is about.""" + + number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="number") + """Identifies the comment number.""" + + +class TeamRemoveMemberAuditEntry(sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, TeamAuditEntryData): + """Audit log entry for a team.remove_member event.""" + + __schema__ = github_schema + __field_names__ = ("is_ldap_mapped",) + is_ldap_mapped = sgqlc.types.Field(Boolean, graphql_name="isLdapMapped") + """Whether the team was mapped to an LDAP Group.""" + + +class TeamRemoveRepositoryAuditEntry( + sgqlc.types.Type, Node, AuditEntry, OrganizationAuditEntryData, RepositoryAuditEntryData, TeamAuditEntryData +): + """Audit log entry for a team.remove_repository event.""" + + __schema__ = github_schema + __field_names__ = ("is_ldap_mapped",) + is_ldap_mapped = sgqlc.types.Field(Boolean, graphql_name="isLdapMapped") + """Whether the team was mapped to an LDAP Group.""" + + +class Topic(sgqlc.types.Type, Node, Starrable): + """A topic aggregates entities that are related to a subject.""" + + __schema__ = github_schema + __field_names__ = ("name", "related_topics", "repositories") + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The topic's name.""" + + related_topics = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null("Topic"))), + graphql_name="relatedTopics", + args=sgqlc.types.ArgDict((("first", sgqlc.types.Arg(Int, graphql_name="first", default=3)),)), + ) + """A list of related topics, including aliases of this topic, sorted + with the most relevant first. Returns up to 10 Topics. + + Arguments: + + * `first` (`Int`): How many topics to return. (default: `3`) + """ + + repositories = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryConnection), + graphql_name="repositories", + args=sgqlc.types.ArgDict( + ( + ("privacy", sgqlc.types.Arg(RepositoryPrivacy, graphql_name="privacy", default=None)), + ("order_by", sgqlc.types.Arg(RepositoryOrder, graphql_name="orderBy", default=None)), + ("affiliations", sgqlc.types.Arg(sgqlc.types.list_of(RepositoryAffiliation), graphql_name="affiliations", default=None)), + ( + "owner_affiliations", + sgqlc.types.Arg( + sgqlc.types.list_of(RepositoryAffiliation), graphql_name="ownerAffiliations", default=("OWNER", "COLLABORATOR") + ), + ), + ("is_locked", sgqlc.types.Arg(Boolean, graphql_name="isLocked", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("sponsorable_only", sgqlc.types.Arg(Boolean, graphql_name="sponsorableOnly", default=False)), + ) + ), + ) + """A list of repositories. + + Arguments: + + * `privacy` (`RepositoryPrivacy`): If non-null, filters + repositories according to privacy + * `order_by` (`RepositoryOrder`): Ordering options for + repositories returned from the connection + * `affiliations` (`[RepositoryAffiliation]`): Array of viewer's + affiliation options for repositories returned from the + connection. For example, OWNER will include only repositories + that the current viewer owns. + * `owner_affiliations` (`[RepositoryAffiliation]`): Array of + owner's affiliation options for repositories returned from the + connection. For example, OWNER will include only repositories + that the organization or user being viewed owns. (default: + `[OWNER, COLLABORATOR]`) + * `is_locked` (`Boolean`): If non-null, filters repositories + according to whether they have been locked + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `sponsorable_only` (`Boolean`): If true, only repositories whose + owner can be sponsored via GitHub Sponsors will be returned. + (default: `false`) + """ + + +class TransferredEvent(sgqlc.types.Type, Node): + """Represents a 'transferred' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "from_repository", "issue") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + from_repository = sgqlc.types.Field(Repository, graphql_name="fromRepository") + """The repository this came from""" + + issue = sgqlc.types.Field(sgqlc.types.non_null(Issue), graphql_name="issue") + """Identifies the issue associated with the event.""" + + +class Tree(sgqlc.types.Type, Node, GitObject): + """Represents a Git tree.""" + + __schema__ = github_schema + __field_names__ = ("entries",) + entries = sgqlc.types.Field(sgqlc.types.list_of(sgqlc.types.non_null(TreeEntry)), graphql_name="entries") + """A list of tree entries.""" + + +class UnassignedEvent(sgqlc.types.Type, Node): + """Represents an 'unassigned' event on any assignable object.""" + + __schema__ = github_schema + __field_names__ = ("actor", "assignable", "assignee", "created_at") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + assignable = sgqlc.types.Field(sgqlc.types.non_null(Assignable), graphql_name="assignable") + """Identifies the assignable associated with the event.""" + + assignee = sgqlc.types.Field("Assignee", graphql_name="assignee") + """Identifies the user or mannequin that was unassigned.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + +class UnknownSignature(sgqlc.types.Type, GitSignature): + """Represents an unknown signature on a Commit or Tag.""" + + __schema__ = github_schema + __field_names__ = () + + +class UnlabeledEvent(sgqlc.types.Type, Node): + """Represents an 'unlabeled' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "label", "labelable") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + label = sgqlc.types.Field(sgqlc.types.non_null(Label), graphql_name="label") + """Identifies the label associated with the 'unlabeled' event.""" + + labelable = sgqlc.types.Field(sgqlc.types.non_null(Labelable), graphql_name="labelable") + """Identifies the `Labelable` associated with the event.""" + + +class UnlockedEvent(sgqlc.types.Type, Node): + """Represents an 'unlocked' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "lockable") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + lockable = sgqlc.types.Field(sgqlc.types.non_null(Lockable), graphql_name="lockable") + """Object that was unlocked.""" + + +class UnmarkedAsDuplicateEvent(sgqlc.types.Type, Node): + """Represents an 'unmarked_as_duplicate' event on a given issue or + pull request. + """ + + __schema__ = github_schema + __field_names__ = ("actor", "canonical", "created_at", "duplicate", "is_cross_repository") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + canonical = sgqlc.types.Field("IssueOrPullRequest", graphql_name="canonical") + """The authoritative issue or pull request which has been duplicated + by another. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + duplicate = sgqlc.types.Field("IssueOrPullRequest", graphql_name="duplicate") + """The issue or pull request which has been marked as a duplicate of + another. + """ + + is_cross_repository = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCrossRepository") + """Canonical and duplicate belong to different repositories.""" + + +class UnpinnedEvent(sgqlc.types.Type, Node): + """Represents an 'unpinned' event on a given issue or pull request.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "issue") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + issue = sgqlc.types.Field(sgqlc.types.non_null(Issue), graphql_name="issue") + """Identifies the issue associated with the event.""" + + +class UnsubscribedEvent(sgqlc.types.Type, Node): + """Represents an 'unsubscribed' event on a given `Subscribable`.""" + + __schema__ = github_schema + __field_names__ = ("actor", "created_at", "subscribable") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + subscribable = sgqlc.types.Field(sgqlc.types.non_null(Subscribable), graphql_name="subscribable") + """Object referenced by event.""" + + +class User( + sgqlc.types.Type, + Node, + Actor, + PackageOwner, + ProjectOwner, + ProjectNextOwner, + RepositoryDiscussionAuthor, + RepositoryDiscussionCommentAuthor, + RepositoryOwner, + UniformResourceLocatable, + ProfileOwner, + Sponsorable, +): + """A user is an individual's account on GitHub that owns repositories + and can make new content. + """ + + __schema__ = github_schema + __field_names__ = ( + "bio", + "bio_html", + "can_receive_organization_emails_when_notifications_restricted", + "commit_comments", + "company", + "company_html", + "contributions_collection", + "created_at", + "database_id", + "followers", + "following", + "gist", + "gist_comments", + "gists", + "hovercard", + "interaction_ability", + "is_bounty_hunter", + "is_campus_expert", + "is_developer_program_member", + "is_employee", + "is_following_viewer", + "is_git_hub_star", + "is_hireable", + "is_site_admin", + "is_viewer", + "issue_comments", + "issues", + "organization", + "organization_verified_domain_emails", + "organizations", + "public_keys", + "pull_requests", + "repositories_contributed_to", + "saved_replies", + "starred_repositories", + "status", + "top_repositories", + "twitter_username", + "updated_at", + "viewer_can_follow", + "viewer_is_following", + "watching", + ) + bio = sgqlc.types.Field(String, graphql_name="bio") + """The user's public profile bio.""" + + bio_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="bioHTML") + """The user's public profile bio as HTML.""" + + can_receive_organization_emails_when_notifications_restricted = sgqlc.types.Field( + sgqlc.types.non_null(Boolean), + graphql_name="canReceiveOrganizationEmailsWhenNotificationsRestricted", + args=sgqlc.types.ArgDict((("login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="login", default=None)),)), + ) + """Could this user receive email notifications, if the organization + had notification restrictions enabled? + + Arguments: + + * `login` (`String!`): The login of the organization to check. + """ + + commit_comments = sgqlc.types.Field( + sgqlc.types.non_null(CommitCommentConnection), + graphql_name="commitComments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of commit comments made by this user. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + company = sgqlc.types.Field(String, graphql_name="company") + """The user's public profile company.""" + + company_html = sgqlc.types.Field(sgqlc.types.non_null(HTML), graphql_name="companyHTML") + """The user's public profile company as HTML.""" + + contributions_collection = sgqlc.types.Field( + sgqlc.types.non_null(ContributionsCollection), + graphql_name="contributionsCollection", + args=sgqlc.types.ArgDict( + ( + ("organization_id", sgqlc.types.Arg(ID, graphql_name="organizationID", default=None)), + ("from_", sgqlc.types.Arg(DateTime, graphql_name="from", default=None)), + ("to", sgqlc.types.Arg(DateTime, graphql_name="to", default=None)), + ) + ), + ) + """The collection of contributions this user has made to different + repositories. + + Arguments: + + * `organization_id` (`ID`): The ID of the organization used to + filter contributions. + * `from_` (`DateTime`): Only contributions made at this time or + later will be counted. If omitted, defaults to a year ago. + * `to` (`DateTime`): Only contributions made before and up to + (including) this time will be counted. If omitted, defaults to + the current time or one year from the provided from argument. + """ + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + followers = sgqlc.types.Field( + sgqlc.types.non_null(FollowerConnection), + graphql_name="followers", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users the given user is followed by. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + following = sgqlc.types.Field( + sgqlc.types.non_null(FollowingConnection), + graphql_name="following", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of users the given user is following. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + gist = sgqlc.types.Field( + Gist, + graphql_name="gist", + args=sgqlc.types.ArgDict((("name", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="name", default=None)),)), + ) + """Find gist by repo name. + + Arguments: + + * `name` (`String!`): The gist name to find. + """ + + gist_comments = sgqlc.types.Field( + sgqlc.types.non_null(GistCommentConnection), + graphql_name="gistComments", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of gist comments made by this user. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + gists = sgqlc.types.Field( + sgqlc.types.non_null(GistConnection), + graphql_name="gists", + args=sgqlc.types.ArgDict( + ( + ("privacy", sgqlc.types.Arg(GistPrivacy, graphql_name="privacy", default=None)), + ("order_by", sgqlc.types.Arg(GistOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of the Gists the user has created. + + Arguments: + + * `privacy` (`GistPrivacy`): Filters Gists according to privacy. + * `order_by` (`GistOrder`): Ordering options for gists returned + from the connection + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + hovercard = sgqlc.types.Field( + sgqlc.types.non_null(Hovercard), + graphql_name="hovercard", + args=sgqlc.types.ArgDict((("primary_subject_id", sgqlc.types.Arg(ID, graphql_name="primarySubjectId", default=None)),)), + ) + """The hovercard information for this user in a given context + + Arguments: + + * `primary_subject_id` (`ID`): The ID of the subject to get the + hovercard in the context of + """ + + interaction_ability = sgqlc.types.Field(RepositoryInteractionAbility, graphql_name="interactionAbility") + """The interaction ability settings for this user.""" + + is_bounty_hunter = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isBountyHunter") + """Whether or not this user is a participant in the GitHub Security + Bug Bounty. + """ + + is_campus_expert = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isCampusExpert") + """Whether or not this user is a participant in the GitHub Campus + Experts Program. + """ + + is_developer_program_member = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isDeveloperProgramMember") + """Whether or not this user is a GitHub Developer Program member.""" + + is_employee = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isEmployee") + """Whether or not this user is a GitHub employee.""" + + is_following_viewer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isFollowingViewer") + """Whether or not this user is following the viewer. Inverse of + viewer_is_following + """ + + is_git_hub_star = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isGitHubStar") + """Whether or not this user is a member of the GitHub Stars Program.""" + + is_hireable = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isHireable") + """Whether or not the user has marked themselves as for hire.""" + + is_site_admin = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isSiteAdmin") + """Whether or not this user is a site administrator.""" + + is_viewer = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isViewer") + """Whether or not this user is the viewing user.""" + + issue_comments = sgqlc.types.Field( + sgqlc.types.non_null(IssueCommentConnection), + graphql_name="issueComments", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(IssueCommentOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of issue comments made by this user. + + Arguments: + + * `order_by` (`IssueCommentOrder`): Ordering options for issue + comments returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + issues = sgqlc.types.Field( + sgqlc.types.non_null(IssueConnection), + graphql_name="issues", + args=sgqlc.types.ArgDict( + ( + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("states", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(IssueState)), graphql_name="states", default=None)), + ("filter_by", sgqlc.types.Arg(IssueFilters, graphql_name="filterBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of issues associated with this user. + + Arguments: + + * `order_by` (`IssueOrder`): Ordering options for issues returned + from the connection. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `states` (`[IssueState!]`): A list of states to filter the + issues by. + * `filter_by` (`IssueFilters`): Filtering options for issues + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + organization = sgqlc.types.Field( + Organization, + graphql_name="organization", + args=sgqlc.types.ArgDict((("login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="login", default=None)),)), + ) + """Find an organization by its login that the user belongs to. + + Arguments: + + * `login` (`String!`): The login of the organization to find. + """ + + organization_verified_domain_emails = sgqlc.types.Field( + sgqlc.types.non_null(sgqlc.types.list_of(sgqlc.types.non_null(String))), + graphql_name="organizationVerifiedDomainEmails", + args=sgqlc.types.ArgDict((("login", sgqlc.types.Arg(sgqlc.types.non_null(String), graphql_name="login", default=None)),)), + ) + """Verified email addresses that match verified domains for a + specified organization the user is a member of. + + Arguments: + + * `login` (`String!`): The login of the organization to match + verified domains from. + """ + + organizations = sgqlc.types.Field( + sgqlc.types.non_null(OrganizationConnection), + graphql_name="organizations", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of organizations the user belongs to. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + public_keys = sgqlc.types.Field( + sgqlc.types.non_null(PublicKeyConnection), + graphql_name="publicKeys", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of public keys associated with this user. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pull_requests = sgqlc.types.Field( + sgqlc.types.non_null(PullRequestConnection), + graphql_name="pullRequests", + args=sgqlc.types.ArgDict( + ( + ( + "states", + sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(PullRequestState)), graphql_name="states", default=None), + ), + ("labels", sgqlc.types.Arg(sgqlc.types.list_of(sgqlc.types.non_null(String)), graphql_name="labels", default=None)), + ("head_ref_name", sgqlc.types.Arg(String, graphql_name="headRefName", default=None)), + ("base_ref_name", sgqlc.types.Arg(String, graphql_name="baseRefName", default=None)), + ("order_by", sgqlc.types.Arg(IssueOrder, graphql_name="orderBy", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of pull requests associated with this user. + + Arguments: + + * `states` (`[PullRequestState!]`): A list of states to filter the + pull requests by. + * `labels` (`[String!]`): A list of label names to filter the pull + requests by. + * `head_ref_name` (`String`): The head ref name to filter the pull + requests by. + * `base_ref_name` (`String`): The base ref name to filter the pull + requests by. + * `order_by` (`IssueOrder`): Ordering options for pull requests + returned from the connection. + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + repositories_contributed_to = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryConnection), + graphql_name="repositoriesContributedTo", + args=sgqlc.types.ArgDict( + ( + ("privacy", sgqlc.types.Arg(RepositoryPrivacy, graphql_name="privacy", default=None)), + ("order_by", sgqlc.types.Arg(RepositoryOrder, graphql_name="orderBy", default=None)), + ("is_locked", sgqlc.types.Arg(Boolean, graphql_name="isLocked", default=None)), + ("include_user_repositories", sgqlc.types.Arg(Boolean, graphql_name="includeUserRepositories", default=None)), + ( + "contribution_types", + sgqlc.types.Arg(sgqlc.types.list_of(RepositoryContributionType), graphql_name="contributionTypes", default=None), + ), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of repositories that the user recently contributed to. + + Arguments: + + * `privacy` (`RepositoryPrivacy`): If non-null, filters + repositories according to privacy + * `order_by` (`RepositoryOrder`): Ordering options for + repositories returned from the connection + * `is_locked` (`Boolean`): If non-null, filters repositories + according to whether they have been locked + * `include_user_repositories` (`Boolean`): If true, include user + repositories + * `contribution_types` (`[RepositoryContributionType]`): If non- + null, include only the specified types of contributions. The + GitHub.com UI uses [COMMIT, ISSUE, PULL_REQUEST, REPOSITORY] + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + saved_replies = sgqlc.types.Field( + SavedReplyConnection, + graphql_name="savedReplies", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ( + "order_by", + sgqlc.types.Arg(SavedReplyOrder, graphql_name="orderBy", default={"field": "UPDATED_AT", "direction": "DESC"}), + ), + ) + ), + ) + """Replies this user has saved + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`SavedReplyOrder`): The field to order saved replies + by. (default: `{field: UPDATED_AT, direction: DESC}`) + """ + + starred_repositories = sgqlc.types.Field( + sgqlc.types.non_null(StarredRepositoryConnection), + graphql_name="starredRepositories", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("owned_by_viewer", sgqlc.types.Arg(Boolean, graphql_name="ownedByViewer", default=None)), + ("order_by", sgqlc.types.Arg(StarOrder, graphql_name="orderBy", default=None)), + ) + ), + ) + """Repositories the user has starred. + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `owned_by_viewer` (`Boolean`): Filters starred repositories to + only return repositories owned by the viewer. + * `order_by` (`StarOrder`): Order for connection + """ + + status = sgqlc.types.Field("UserStatus", graphql_name="status") + """The user's description of what they're currently doing.""" + + top_repositories = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryConnection), + graphql_name="topRepositories", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ("order_by", sgqlc.types.Arg(sgqlc.types.non_null(RepositoryOrder), graphql_name="orderBy", default=None)), + ("since", sgqlc.types.Arg(DateTime, graphql_name="since", default=None)), + ) + ), + ) + """Repositories the user has contributed to, ordered by contribution + rank, plus repositories the user has created + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + * `order_by` (`RepositoryOrder!`): Ordering options for + repositories returned from the connection + * `since` (`DateTime`): How far back in time to fetch contributed + repositories + """ + + twitter_username = sgqlc.types.Field(String, graphql_name="twitterUsername") + """The user's Twitter username.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + viewer_can_follow = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerCanFollow") + """Whether or not the viewer is able to follow the user.""" + + viewer_is_following = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="viewerIsFollowing") + """Whether or not this user is followed by the viewer. Inverse of + is_following_viewer. + """ + + watching = sgqlc.types.Field( + sgqlc.types.non_null(RepositoryConnection), + graphql_name="watching", + args=sgqlc.types.ArgDict( + ( + ("privacy", sgqlc.types.Arg(RepositoryPrivacy, graphql_name="privacy", default=None)), + ("order_by", sgqlc.types.Arg(RepositoryOrder, graphql_name="orderBy", default=None)), + ("affiliations", sgqlc.types.Arg(sgqlc.types.list_of(RepositoryAffiliation), graphql_name="affiliations", default=None)), + ( + "owner_affiliations", + sgqlc.types.Arg( + sgqlc.types.list_of(RepositoryAffiliation), graphql_name="ownerAffiliations", default=("OWNER", "COLLABORATOR") + ), + ), + ("is_locked", sgqlc.types.Arg(Boolean, graphql_name="isLocked", default=None)), + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """A list of repositories the given user is watching. + + Arguments: + + * `privacy` (`RepositoryPrivacy`): If non-null, filters + repositories according to privacy + * `order_by` (`RepositoryOrder`): Ordering options for + repositories returned from the connection + * `affiliations` (`[RepositoryAffiliation]`): Affiliation options + for repositories returned from the connection. If none + specified, the results will include repositories for which the + current viewer is an owner or collaborator, or member. + * `owner_affiliations` (`[RepositoryAffiliation]`): Array of + owner's affiliation options for repositories returned from the + connection. For example, OWNER will include only repositories + that the organization or user being viewed owns. (default: + `[OWNER, COLLABORATOR]`) + * `is_locked` (`Boolean`): If non-null, filters repositories + according to whether they have been locked + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + +class UserBlockedEvent(sgqlc.types.Type, Node): + """Represents a 'user_blocked' event on a given user.""" + + __schema__ = github_schema + __field_names__ = ("actor", "block_duration", "created_at", "subject") + actor = sgqlc.types.Field(Actor, graphql_name="actor") + """Identifies the actor who performed the event.""" + + block_duration = sgqlc.types.Field(sgqlc.types.non_null(UserBlockDuration), graphql_name="blockDuration") + """Number of days that the user was blocked for.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + subject = sgqlc.types.Field(User, graphql_name="subject") + """The user who was blocked.""" + + +class UserContentEdit(sgqlc.types.Type, Node): + """An edit on user content""" + + __schema__ = github_schema + __field_names__ = ("created_at", "deleted_at", "deleted_by", "diff", "edited_at", "editor", "updated_at") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + deleted_at = sgqlc.types.Field(DateTime, graphql_name="deletedAt") + """Identifies the date and time when the object was deleted.""" + + deleted_by = sgqlc.types.Field(Actor, graphql_name="deletedBy") + """The actor who deleted this content""" + + diff = sgqlc.types.Field(String, graphql_name="diff") + """A summary of the changes for this edit""" + + edited_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="editedAt") + """When this content was edited""" + + editor = sgqlc.types.Field(Actor, graphql_name="editor") + """The actor who edited this content""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class UserStatus(sgqlc.types.Type, Node): + """The user's description of what they're currently doing.""" + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "emoji", + "emoji_html", + "expires_at", + "indicates_limited_availability", + "message", + "organization", + "updated_at", + "user", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + emoji = sgqlc.types.Field(String, graphql_name="emoji") + """An emoji summarizing the user's status.""" + + emoji_html = sgqlc.types.Field(HTML, graphql_name="emojiHTML") + """The status emoji as HTML.""" + + expires_at = sgqlc.types.Field(DateTime, graphql_name="expiresAt") + """If set, the status will not be shown after this date.""" + + indicates_limited_availability = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="indicatesLimitedAvailability") + """Whether this status indicates the user is not fully available on + GitHub. + """ + + message = sgqlc.types.Field(String, graphql_name="message") + """A brief message describing what the user is doing.""" + + organization = sgqlc.types.Field(Organization, graphql_name="organization") + """The organization whose members can see this status. If null, this + status is publicly visible. + """ + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + user = sgqlc.types.Field(sgqlc.types.non_null(User), graphql_name="user") + """The user who has this status.""" + + +class VerifiableDomain(sgqlc.types.Type, Node): + """A domain that can be verified or approved for an organization or + an enterprise. + """ + + __schema__ = github_schema + __field_names__ = ( + "created_at", + "database_id", + "dns_host_name", + "domain", + "has_found_host_name", + "has_found_verification_token", + "is_approved", + "is_required_for_policy_enforcement", + "is_verified", + "owner", + "punycode_encoded_domain", + "token_expiration_time", + "updated_at", + "verification_token", + ) + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + dns_host_name = sgqlc.types.Field(URI, graphql_name="dnsHostName") + """The DNS host name that should be used for verification.""" + + domain = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="domain") + """The unicode encoded domain.""" + + has_found_host_name = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasFoundHostName") + """Whether a TXT record for verification with the expected host name + was found. + """ + + has_found_verification_token = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="hasFoundVerificationToken") + """Whether a TXT record for verification with the expected + verification token was found. + """ + + is_approved = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isApproved") + """Whether or not the domain is approved.""" + + is_required_for_policy_enforcement = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isRequiredForPolicyEnforcement") + """Whether this domain is required to exist for an organization or + enterprise policy to be enforced. + """ + + is_verified = sgqlc.types.Field(sgqlc.types.non_null(Boolean), graphql_name="isVerified") + """Whether or not the domain is verified.""" + + owner = sgqlc.types.Field(sgqlc.types.non_null("VerifiableDomainOwner"), graphql_name="owner") + """The owner of the domain.""" + + punycode_encoded_domain = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="punycodeEncodedDomain") + """The punycode encoded domain.""" + + token_expiration_time = sgqlc.types.Field(DateTime, graphql_name="tokenExpirationTime") + """The time that the current verification token will expire.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + verification_token = sgqlc.types.Field(String, graphql_name="verificationToken") + """The current verification token for the domain.""" + + +class ViewerHovercardContext(sgqlc.types.Type, HovercardContext): + """A hovercard context with a message describing how the viewer is + related. + """ + + __schema__ = github_schema + __field_names__ = ("viewer",) + viewer = sgqlc.types.Field(sgqlc.types.non_null(User), graphql_name="viewer") + """Identifies the user who is related to this context.""" + + +class Workflow(sgqlc.types.Type, Node): + """A workflow contains meta information about an Actions workflow + file. + """ + + __schema__ = github_schema + __field_names__ = ("created_at", "database_id", "name", "updated_at") + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + name = sgqlc.types.Field(sgqlc.types.non_null(String), graphql_name="name") + """The name of the workflow.""" + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + +class WorkflowRun(sgqlc.types.Type, Node): + """A workflow run.""" + + __schema__ = github_schema + __field_names__ = ( + "check_suite", + "created_at", + "database_id", + "deployment_reviews", + "pending_deployment_requests", + "resource_path", + "run_number", + "updated_at", + "url", + "workflow", + ) + check_suite = sgqlc.types.Field(sgqlc.types.non_null(CheckSuite), graphql_name="checkSuite") + """The check suite this workflow run belongs to.""" + + created_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="createdAt") + """Identifies the date and time when the object was created.""" + + database_id = sgqlc.types.Field(Int, graphql_name="databaseId") + """Identifies the primary key from the database.""" + + deployment_reviews = sgqlc.types.Field( + sgqlc.types.non_null(DeploymentReviewConnection), + graphql_name="deploymentReviews", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The log of deployment reviews + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + pending_deployment_requests = sgqlc.types.Field( + sgqlc.types.non_null(DeploymentRequestConnection), + graphql_name="pendingDeploymentRequests", + args=sgqlc.types.ArgDict( + ( + ("after", sgqlc.types.Arg(String, graphql_name="after", default=None)), + ("before", sgqlc.types.Arg(String, graphql_name="before", default=None)), + ("first", sgqlc.types.Arg(Int, graphql_name="first", default=None)), + ("last", sgqlc.types.Arg(Int, graphql_name="last", default=None)), + ) + ), + ) + """The pending deployment requests of all check runs in this workflow + run + + Arguments: + + * `after` (`String`): Returns the elements in the list that come + after the specified cursor. + * `before` (`String`): Returns the elements in the list that come + before the specified cursor. + * `first` (`Int`): Returns the first _n_ elements from the list. + * `last` (`Int`): Returns the last _n_ elements from the list. + """ + + resource_path = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="resourcePath") + """The HTTP path for this workflow run""" + + run_number = sgqlc.types.Field(sgqlc.types.non_null(Int), graphql_name="runNumber") + """A number that uniquely identifies this workflow run in its parent + workflow. + """ + + updated_at = sgqlc.types.Field(sgqlc.types.non_null(DateTime), graphql_name="updatedAt") + """Identifies the date and time when the object was last updated.""" + + url = sgqlc.types.Field(sgqlc.types.non_null(URI), graphql_name="url") + """The HTTP URL for this workflow run""" + + workflow = sgqlc.types.Field(sgqlc.types.non_null(Workflow), graphql_name="workflow") + """The workflow executed in this workflow run.""" + + +######################################################################## +# Unions +######################################################################## +class Assignee(sgqlc.types.Union): + """Types that can be assigned to issues.""" + + __schema__ = github_schema + __types__ = (Bot, Mannequin, Organization, User) + + +class AuditEntryActor(sgqlc.types.Union): + """Types that can initiate an audit log event.""" + + __schema__ = github_schema + __types__ = (Bot, Organization, User) + + +class BranchActorAllowanceActor(sgqlc.types.Union): + """Types which can be actors for `BranchActorAllowance` objects.""" + + __schema__ = github_schema + __types__ = (App, Team, User) + + +class Closer(sgqlc.types.Union): + """The object which triggered a `ClosedEvent`.""" + + __schema__ = github_schema + __types__ = (Commit, PullRequest) + + +class CreatedIssueOrRestrictedContribution(sgqlc.types.Union): + """Represents either a issue the viewer can access or a restricted + contribution. + """ + + __schema__ = github_schema + __types__ = (CreatedIssueContribution, RestrictedContribution) + + +class CreatedPullRequestOrRestrictedContribution(sgqlc.types.Union): + """Represents either a pull request the viewer can access or a + restricted contribution. + """ + + __schema__ = github_schema + __types__ = (CreatedPullRequestContribution, RestrictedContribution) + + +class CreatedRepositoryOrRestrictedContribution(sgqlc.types.Union): + """Represents either a repository the viewer can access or a + restricted contribution. + """ + + __schema__ = github_schema + __types__ = (CreatedRepositoryContribution, RestrictedContribution) + + +class DeploymentReviewer(sgqlc.types.Union): + """Users and teams.""" + + __schema__ = github_schema + __types__ = (Team, User) + + +class EnterpriseMember(sgqlc.types.Union): + """An object that is a member of an enterprise.""" + + __schema__ = github_schema + __types__ = (EnterpriseUserAccount, User) + + +class IpAllowListOwner(sgqlc.types.Union): + """Types that can own an IP allow list.""" + + __schema__ = github_schema + __types__ = (App, Enterprise, Organization) + + +class IssueOrPullRequest(sgqlc.types.Union): + """Used for return value of Repository.issueOrPullRequest.""" + + __schema__ = github_schema + __types__ = (Issue, PullRequest) + + +class IssueTimelineItem(sgqlc.types.Union): + """An item in an issue timeline""" + + __schema__ = github_schema + __types__ = ( + AssignedEvent, + ClosedEvent, + Commit, + CrossReferencedEvent, + DemilestonedEvent, + IssueComment, + LabeledEvent, + LockedEvent, + MilestonedEvent, + ReferencedEvent, + RenamedTitleEvent, + ReopenedEvent, + SubscribedEvent, + TransferredEvent, + UnassignedEvent, + UnlabeledEvent, + UnlockedEvent, + UnsubscribedEvent, + UserBlockedEvent, + ) + + +class IssueTimelineItems(sgqlc.types.Union): + """An item in an issue timeline""" + + __schema__ = github_schema + __types__ = ( + AddedToProjectEvent, + AssignedEvent, + ClosedEvent, + CommentDeletedEvent, + ConnectedEvent, + ConvertedNoteToIssueEvent, + ConvertedToDiscussionEvent, + CrossReferencedEvent, + DemilestonedEvent, + DisconnectedEvent, + IssueComment, + LabeledEvent, + LockedEvent, + MarkedAsDuplicateEvent, + MentionedEvent, + MilestonedEvent, + MovedColumnsInProjectEvent, + PinnedEvent, + ReferencedEvent, + RemovedFromProjectEvent, + RenamedTitleEvent, + ReopenedEvent, + SubscribedEvent, + TransferredEvent, + UnassignedEvent, + UnlabeledEvent, + UnlockedEvent, + UnmarkedAsDuplicateEvent, + UnpinnedEvent, + UnsubscribedEvent, + UserBlockedEvent, + ) + + +class MilestoneItem(sgqlc.types.Union): + """Types that can be inside a Milestone.""" + + __schema__ = github_schema + __types__ = (Issue, PullRequest) + + +class OrgRestoreMemberAuditEntryMembership(sgqlc.types.Union): + """Types of memberships that can be restored for an Organization + member. + """ + + __schema__ = github_schema + __types__ = ( + OrgRestoreMemberMembershipOrganizationAuditEntryData, + OrgRestoreMemberMembershipRepositoryAuditEntryData, + OrgRestoreMemberMembershipTeamAuditEntryData, + ) + + +class OrganizationAuditEntry(sgqlc.types.Union): + """An audit entry in an organization audit log.""" + + __schema__ = github_schema + __types__ = ( + MembersCanDeleteReposClearAuditEntry, + MembersCanDeleteReposDisableAuditEntry, + MembersCanDeleteReposEnableAuditEntry, + OauthApplicationCreateAuditEntry, + OrgAddBillingManagerAuditEntry, + OrgAddMemberAuditEntry, + OrgBlockUserAuditEntry, + OrgConfigDisableCollaboratorsOnlyAuditEntry, + OrgConfigEnableCollaboratorsOnlyAuditEntry, + OrgCreateAuditEntry, + OrgDisableOauthAppRestrictionsAuditEntry, + OrgDisableSamlAuditEntry, + OrgDisableTwoFactorRequirementAuditEntry, + OrgEnableOauthAppRestrictionsAuditEntry, + OrgEnableSamlAuditEntry, + OrgEnableTwoFactorRequirementAuditEntry, + OrgInviteMemberAuditEntry, + OrgInviteToBusinessAuditEntry, + OrgOauthAppAccessApprovedAuditEntry, + OrgOauthAppAccessDeniedAuditEntry, + OrgOauthAppAccessRequestedAuditEntry, + OrgRemoveBillingManagerAuditEntry, + OrgRemoveMemberAuditEntry, + OrgRemoveOutsideCollaboratorAuditEntry, + OrgRestoreMemberAuditEntry, + OrgUnblockUserAuditEntry, + OrgUpdateDefaultRepositoryPermissionAuditEntry, + OrgUpdateMemberAuditEntry, + OrgUpdateMemberRepositoryCreationPermissionAuditEntry, + OrgUpdateMemberRepositoryInvitationPermissionAuditEntry, + PrivateRepositoryForkingDisableAuditEntry, + PrivateRepositoryForkingEnableAuditEntry, + RepoAccessAuditEntry, + RepoAddMemberAuditEntry, + RepoAddTopicAuditEntry, + RepoArchivedAuditEntry, + RepoChangeMergeSettingAuditEntry, + RepoConfigDisableAnonymousGitAccessAuditEntry, + RepoConfigDisableCollaboratorsOnlyAuditEntry, + RepoConfigDisableContributorsOnlyAuditEntry, + RepoConfigDisableSockpuppetDisallowedAuditEntry, + RepoConfigEnableAnonymousGitAccessAuditEntry, + RepoConfigEnableCollaboratorsOnlyAuditEntry, + RepoConfigEnableContributorsOnlyAuditEntry, + RepoConfigEnableSockpuppetDisallowedAuditEntry, + RepoConfigLockAnonymousGitAccessAuditEntry, + RepoConfigUnlockAnonymousGitAccessAuditEntry, + RepoCreateAuditEntry, + RepoDestroyAuditEntry, + RepoRemoveMemberAuditEntry, + RepoRemoveTopicAuditEntry, + RepositoryVisibilityChangeDisableAuditEntry, + RepositoryVisibilityChangeEnableAuditEntry, + TeamAddMemberAuditEntry, + TeamAddRepositoryAuditEntry, + TeamChangeParentTeamAuditEntry, + TeamRemoveMemberAuditEntry, + TeamRemoveRepositoryAuditEntry, + ) + + +class PermissionGranter(sgqlc.types.Union): + """Types that can grant permissions on a repository to a user""" + + __schema__ = github_schema + __types__ = (Organization, Repository, Team) + + +class PinnableItem(sgqlc.types.Union): + """Types that can be pinned to a profile page.""" + + __schema__ = github_schema + __types__ = (Gist, Repository) + + +class ProjectCardItem(sgqlc.types.Union): + """Types that can be inside Project Cards.""" + + __schema__ = github_schema + __types__ = (Issue, PullRequest) + + +class ProjectNextItemContent(sgqlc.types.Union): + """Types that can be inside Project Items.""" + + __schema__ = github_schema + __types__ = (DraftIssue, Issue, PullRequest) + + +class PullRequestTimelineItem(sgqlc.types.Union): + """An item in a pull request timeline""" + + __schema__ = github_schema + __types__ = ( + AssignedEvent, + BaseRefDeletedEvent, + BaseRefForcePushedEvent, + ClosedEvent, + Commit, + CommitCommentThread, + CrossReferencedEvent, + DemilestonedEvent, + DeployedEvent, + DeploymentEnvironmentChangedEvent, + HeadRefDeletedEvent, + HeadRefForcePushedEvent, + HeadRefRestoredEvent, + IssueComment, + LabeledEvent, + LockedEvent, + MergedEvent, + MilestonedEvent, + PullRequestReview, + PullRequestReviewComment, + PullRequestReviewThread, + ReferencedEvent, + RenamedTitleEvent, + ReopenedEvent, + ReviewDismissedEvent, + ReviewRequestRemovedEvent, + ReviewRequestedEvent, + SubscribedEvent, + UnassignedEvent, + UnlabeledEvent, + UnlockedEvent, + UnsubscribedEvent, + UserBlockedEvent, + ) + + +class PullRequestTimelineItems(sgqlc.types.Union): + """An item in a pull request timeline""" + + __schema__ = github_schema + __types__ = ( + AddedToProjectEvent, + AssignedEvent, + AutoMergeDisabledEvent, + AutoMergeEnabledEvent, + AutoRebaseEnabledEvent, + AutoSquashEnabledEvent, + AutomaticBaseChangeFailedEvent, + AutomaticBaseChangeSucceededEvent, + BaseRefChangedEvent, + BaseRefDeletedEvent, + BaseRefForcePushedEvent, + ClosedEvent, + CommentDeletedEvent, + ConnectedEvent, + ConvertToDraftEvent, + ConvertedNoteToIssueEvent, + ConvertedToDiscussionEvent, + CrossReferencedEvent, + DemilestonedEvent, + DeployedEvent, + DeploymentEnvironmentChangedEvent, + DisconnectedEvent, + HeadRefDeletedEvent, + HeadRefForcePushedEvent, + HeadRefRestoredEvent, + IssueComment, + LabeledEvent, + LockedEvent, + MarkedAsDuplicateEvent, + MentionedEvent, + MergedEvent, + MilestonedEvent, + MovedColumnsInProjectEvent, + PinnedEvent, + PullRequestCommit, + PullRequestCommitCommentThread, + PullRequestReview, + PullRequestReviewThread, + PullRequestRevisionMarker, + ReadyForReviewEvent, + ReferencedEvent, + RemovedFromProjectEvent, + RenamedTitleEvent, + ReopenedEvent, + ReviewDismissedEvent, + ReviewRequestRemovedEvent, + ReviewRequestedEvent, + SubscribedEvent, + TransferredEvent, + UnassignedEvent, + UnlabeledEvent, + UnlockedEvent, + UnmarkedAsDuplicateEvent, + UnpinnedEvent, + UnsubscribedEvent, + UserBlockedEvent, + ) + + +class PushAllowanceActor(sgqlc.types.Union): + """Types that can be an actor.""" + + __schema__ = github_schema + __types__ = (App, Team, User) + + +class Reactor(sgqlc.types.Union): + """Types that can be assigned to reactions.""" + + __schema__ = github_schema + __types__ = (Bot, Mannequin, Organization, User) + + +class ReferencedSubject(sgqlc.types.Union): + """Any referencable object""" + + __schema__ = github_schema + __types__ = (Issue, PullRequest) + + +class RenamedTitleSubject(sgqlc.types.Union): + """An object which has a renamable title""" + + __schema__ = github_schema + __types__ = (Issue, PullRequest) + + +class RequestedReviewer(sgqlc.types.Union): + """Types that can be requested reviewers.""" + + __schema__ = github_schema + __types__ = (Mannequin, Team, User) + + +class ReviewDismissalAllowanceActor(sgqlc.types.Union): + """Types that can be an actor.""" + + __schema__ = github_schema + __types__ = (App, Team, User) + + +class SearchResultItem(sgqlc.types.Union): + """The results of a search.""" + + __schema__ = github_schema + __types__ = (App, Discussion, Issue, MarketplaceListing, Organization, PullRequest, Repository, User) + + +class Sponsor(sgqlc.types.Union): + """Entities that can sponsor others via GitHub Sponsors""" + + __schema__ = github_schema + __types__ = (Organization, User) + + +class SponsorableItem(sgqlc.types.Union): + """Entities that can be sponsored via GitHub Sponsors""" + + __schema__ = github_schema + __types__ = (Organization, User) + + +class StatusCheckRollupContext(sgqlc.types.Union): + """Types that can be inside a StatusCheckRollup context.""" + + __schema__ = github_schema + __types__ = (CheckRun, StatusContext) + + +class VerifiableDomainOwner(sgqlc.types.Union): + """Types that can own a verifiable domain.""" + + __schema__ = github_schema + __types__ = (Enterprise, Organization) + + +######################################################################## +# Schema Entry Points +######################################################################## +github_schema.query_type = Query +github_schema.mutation_type = Mutation +github_schema.subscription_type = None diff --git a/airbyte-integrations/connectors/source-github/source_github/graphql.py b/airbyte-integrations/connectors/source-github/source_github/graphql.py new file mode 100644 index 000000000000..2b1d7d1233e5 --- /dev/null +++ b/airbyte-integrations/connectors/source-github/source_github/graphql.py @@ -0,0 +1,51 @@ +# +# Copyright (c) 2022 Airbyte, Inc., all rights reserved. +# + + +import sgqlc.operation + +from . import github_schema + +_schema = github_schema +_schema_root = _schema.github_schema + + +def get_query(owner, name, page_size, next_page_token): + kwargs = {"first": page_size, "order_by": {"field": "UPDATED_AT", "direction": "ASC"}} + if next_page_token: + kwargs["after"] = next_page_token + + op = sgqlc.operation.Operation(_schema_root.query_type) + pull_requests = op.repository(owner=owner, name=name).pull_requests(**kwargs) + pull_requests.nodes.__fields__( + id="node_id", + database_id="id", + number=True, + updated_at="updated_at", + changed_files="changed_files", + deletions=True, + additions=True, + merged=True, + mergeable=True, + can_be_rebased="can_be_rebased", + maintainer_can_modify="maintainer_can_modify", + merge_state_status="merge_state_status", + ) + pull_requests.nodes.repository.__fields__(name=True) + pull_requests.nodes.comments.__fields__(total_count=True) + pull_requests.nodes.commits.__fields__(total_count=True) + reviews = pull_requests.nodes.reviews(first=100, __alias__="review_comments") + reviews.total_count() + reviews.nodes.comments.__fields__(total_count=True) + user = pull_requests.nodes.merged_by(__alias__="merged_by").__as__(_schema_root.User) + user.__fields__( + id="node_id", + database_id="id", + login=True, + avatar_url="avatar_url", + url="html_url", + is_site_admin="site_admin", + ) + pull_requests.page_info.__fields__(has_next_page=True, end_cursor=True) + return str(op) diff --git a/airbyte-integrations/connectors/source-github/source_github/schemas/pull_request_stats.json b/airbyte-integrations/connectors/source-github/source_github/schemas/pull_request_stats.json index 90ebf80f14a2..3c79e753ee8c 100644 --- a/airbyte-integrations/connectors/source-github/source_github/schemas/pull_request_stats.json +++ b/airbyte-integrations/connectors/source-github/source_github/schemas/pull_request_stats.json @@ -18,16 +18,39 @@ "type": ["null", "boolean"] }, "mergeable": { - "type": ["null", "boolean"] + "type": ["null", "string"] }, - "rebaseable": { + "can_be_rebased": { "type": ["null", "boolean"] }, - "mergeable_state": { + "merge_state_status": { "type": ["null", "string"] }, "merged_by": { - "$ref": "user.json" + "type": ["null", "object"], + "properties": { + "login": { + "type": ["null", "string"] + }, + "id": { + "type": ["null", "integer"] + }, + "node_id": { + "type": ["null", "string"] + }, + "avatar_url": { + "type": ["null", "string"] + }, + "html_url": { + "type": ["null", "string"] + }, + "type": { + "type": ["null", "string"] + }, + "site_admin": { + "type": ["null", "boolean"] + } + } }, "comments": { "type": ["null", "integer"] diff --git a/airbyte-integrations/connectors/source-github/source_github/source.py b/airbyte-integrations/connectors/source-github/source_github/source.py index c640c4bed853..822e4bf61695 100644 --- a/airbyte-integrations/connectors/source-github/source_github/source.py +++ b/airbyte-integrations/connectors/source-github/source_github/source.py @@ -212,7 +212,7 @@ def streams(self, config: Mapping[str, Any]) -> List[Stream]: projects_stream, PullRequestCommentReactions(**repository_args_with_start_date), PullRequestCommits(parent=pull_requests_stream, **repository_args), - PullRequestStats(parent=pull_requests_stream, **repository_args_with_start_date), + PullRequestStats(**repository_args_with_start_date), pull_requests_stream, Releases(**repository_args_with_start_date), Repositories(**organization_args_with_start_date), diff --git a/airbyte-integrations/connectors/source-github/source_github/streams.py b/airbyte-integrations/connectors/source-github/source_github/streams.py index f024b7e603fb..06c348e50271 100644 --- a/airbyte-integrations/connectors/source-github/source_github/streams.py +++ b/airbyte-integrations/connectors/source-github/source_github/streams.py @@ -14,6 +14,7 @@ from airbyte_cdk.sources.streams.http import HttpStream, HttpSubStream from requests.exceptions import HTTPError +from .graphql import get_query from .utils import getter DEFAULT_PAGE_SIZE = 100 @@ -722,26 +723,55 @@ def read_records( ) -class PullRequestStats(PullRequestSubstream): +class PullRequestStats(SemiIncrementalMixin, GithubStream): """ - API docs: https://docs.github.com/en/rest/reference/pulls#get-a-pull-request + API docs: https://docs.github.com/en/graphql/reference/objects#pullrequest """ - @property - def record_keys(self) -> List[str]: - return list(self.get_json_schema()["properties"].keys()) + is_sorted = "asc" + http_method = "POST" def path( - self, stream_state: Mapping[str, Any] = None, stream_slice: Mapping[str, Any] = None, next_page_token: Mapping[str, Any] = None + self, *, stream_state: Mapping[str, Any] = None, stream_slice: Mapping[str, Any] = None, next_page_token: Mapping[str, Any] = None ) -> str: - return f"repos/{stream_slice['repository']}/pulls/{stream_slice['pull_request_number']}" + return "graphql" - def parse_response(self, response: requests.Response, stream_slice: Mapping[str, Any], **kwargs) -> Iterable[Mapping]: - yield self.transform(record=response.json(), stream_slice=stream_slice) + def parse_response(self, response: requests.Response, **kwargs) -> Iterable[Mapping]: + nodes = response.json()["data"]["repository"]["pullRequests"]["nodes"] + for record in nodes: + record["review_comments"] = sum([node["comments"]["totalCount"] for node in record["review_comments"]["nodes"]]) + record["comments"] = record["comments"]["totalCount"] + record["commits"] = record["commits"]["totalCount"] + record["repository"] = record["repository"]["name"] + if record["merged_by"]: + record["merged_by"]["type"] = record["merged_by"].pop("__typename") + yield record - def transform(self, record: MutableMapping[str, Any], stream_slice: Mapping[str, Any]) -> MutableMapping[str, Any]: - record = super().transform(record=record, stream_slice=stream_slice) - return {key: value for key, value in record.items() if key in self.record_keys} + def next_page_token(self, response: requests.Response) -> Optional[Mapping[str, Any]]: + pageInfo = response.json()["data"]["repository"]["pullRequests"]["pageInfo"] + if pageInfo["hasNextPage"]: + return pageInfo["endCursor"] + + def request_params( + self, stream_state: Mapping[str, Any], stream_slice: Mapping[str, Any] = None, next_page_token: Mapping[str, Any] = None + ) -> MutableMapping[str, Any]: + return {} + + def request_body_json( + self, + stream_state: Mapping[str, Any], + stream_slice: Mapping[str, Any] = None, + next_page_token: Mapping[str, Any] = None, + ) -> Optional[Mapping]: + organization, name = stream_slice["repository"].split("/") + query = get_query(owner=organization, name=name, page_size=self.page_size, next_page_token=next_page_token) + return {"query": query} + + def request_headers(self, **kwargs) -> Mapping[str, Any]: + base_headers = super().request_headers(**kwargs) + # https://docs.github.com/en/graphql/overview/schema-previews#merge-info-preview + headers = {"Accept": "application/vnd.github.merge-info-preview+json"} + return {**base_headers, **headers} class Reviews(PullRequestSubstream): diff --git a/docs/integrations/sources/github.md b/docs/integrations/sources/github.md index b4a9c367d0e5..73f8e00d7b1c 100644 --- a/docs/integrations/sources/github.md +++ b/docs/integrations/sources/github.md @@ -137,6 +137,7 @@ The GitHub connector should not run into GitHub API limitations under normal usa | Version | Date | Pull Request | Subject | |:--------|:-----------| :--- |:-------------------------------------------------------------------------------------------------------------| +| 0.2.35 | 2022-06-16 | [13763](https://github.com/airbytehq/airbyte/pull/13763) | Use GraphQL for `pull_request_stats` stream | | 0.2.34 | 2022-06-14 | [13707](https://github.com/airbytehq/airbyte/pull/13707) | Fix API sorting, fix `get_starting_point` caching | | 0.2.33 | 2022-06-08 | [13558](https://github.com/airbytehq/airbyte/pull/13558) | Enable caching only for parent streams | | 0.2.32 | 2022-06-07 | [13531](https://github.com/airbytehq/airbyte/pull/13531) | Fix different result from `get_starting_point` when reading by pages |