From fc2033c14c7a6dc1d3322ed344bbe8b0031a1cc4 Mon Sep 17 00:00:00 2001 From: Cat Chen Date: Thu, 1 Aug 2024 16:39:42 -0700 Subject: [PATCH] Set up GraphQL TypeScript client --- .github/workflows/build.yml | 3 + .vscode/settings.json | 2 + bundle/graphql/fragment-masking.d.ts | 19 + bundle/graphql/gql.d.ts | 4 + bundle/graphql/graphql.d.ts | 28763 +++++++++++++ bundle/graphql/index.d.ts | 2 + bundle/index.js | 3340 +- bundle/index.js.map | 2 +- codegen.ts | 28 + eslint.config.js | 2 + package.json | 6 + schema.graphql | 55349 +++++++++++++++++++++++++ src/graphql/fragment-masking.ts | 104 + src/graphql/gql.ts | 28 + src/graphql/graphql.ts | 31646 ++++++++++++++ src/graphql/index.ts | 2 + src/index.ts | 24 +- tsconfig.json | 8 +- yarn.lock | 2375 +- 19 files changed, 121667 insertions(+), 40 deletions(-) create mode 100644 bundle/graphql/fragment-masking.d.ts create mode 100644 bundle/graphql/gql.d.ts create mode 100644 bundle/graphql/graphql.d.ts create mode 100644 bundle/graphql/index.d.ts create mode 100644 codegen.ts create mode 100644 schema.graphql create mode 100644 src/graphql/fragment-masking.ts create mode 100644 src/graphql/gql.ts create mode 100644 src/graphql/graphql.ts create mode 100644 src/graphql/index.ts diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 537f17e..f199694 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -43,6 +43,9 @@ jobs: - name: Install dependencies run: yarn + - name: Codegen + run: yarn codegen + - name: Reformat run: | yarn prettier --write . diff --git a/.vscode/settings.json b/.vscode/settings.json index 1b5a7fc..a81e2fc 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,4 +1,6 @@ { + "typescript.tsdk": "node_modules/typescript/lib", + "typescript.enablePromptUseWorkspaceTsdk": true, "yaml.schemas": { "https://json.schemastore.org/github-action.json": "action.yml", "https://json.schemastore.org/github-funding.json": ".github/FUNDING.yml", diff --git a/bundle/graphql/fragment-masking.d.ts b/bundle/graphql/fragment-masking.d.ts new file mode 100644 index 0000000..a94e387 --- /dev/null +++ b/bundle/graphql/fragment-masking.d.ts @@ -0,0 +1,19 @@ +import { DocumentTypeDecoration, ResultOf } from '@graphql-typed-document-node/core'; +import { Incremental, TypedDocumentString } from './graphql.js'; +export type FragmentType> = TDocumentType extends DocumentTypeDecoration ? [TType] extends [{ + ' $fragmentName'?: infer TKey; +}] ? TKey extends string ? { + ' $fragmentRefs'?: { + [key in TKey]: TType; + }; +} : never : never : never; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: FragmentType>): TType; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: FragmentType> | undefined): TType | undefined; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: FragmentType> | null): TType | null; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: FragmentType> | null | undefined): TType | null | undefined; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: Array>>): Array; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: Array>> | null | undefined): Array | null | undefined; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: ReadonlyArray>>): ReadonlyArray; +export declare function useFragment(_documentNode: DocumentTypeDecoration, fragmentType: ReadonlyArray>> | null | undefined): ReadonlyArray | null | undefined; +export declare function makeFragmentData, FT extends ResultOf>(data: FT, _fragment: F): FragmentType; +export declare function isFragmentReady(queryNode: TypedDocumentString, fragmentNode: TypedDocumentString, data: FragmentType, any>> | null | undefined): data is FragmentType; diff --git a/bundle/graphql/gql.d.ts b/bundle/graphql/gql.d.ts new file mode 100644 index 0000000..ae29ba8 --- /dev/null +++ b/bundle/graphql/gql.d.ts @@ -0,0 +1,4 @@ +/** + * The graphql function is used to parse GraphQL queries into a document that can be used by GraphQL clients. + */ +export declare function graphql(source: '\n query ViewLogin {\n viewer {\n login\n }\n }\n'): typeof import('./graphql.js').ViewLoginDocument; diff --git a/bundle/graphql/graphql.d.ts b/bundle/graphql/graphql.d.ts new file mode 100644 index 0000000..f3a3312 --- /dev/null +++ b/bundle/graphql/graphql.d.ts @@ -0,0 +1,28763 @@ +import { DocumentTypeDecoration } from '@graphql-typed-document-node/core'; +export type Maybe = T | null; +export type InputMaybe = Maybe; +export type Exact = { + [K in keyof T]: T[K]; +}; +export type MakeOptional = Omit & { + [SubKey in K]?: Maybe; +}; +export type MakeMaybe = Omit & { + [SubKey in K]: Maybe; +}; +export type MakeEmpty = { + [_ in K]?: never; +}; +export type Incremental = T | { + [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never; +}; +/** All built-in and custom scalars, mapped to their actual values */ +export type Scalars = { + ID: { + input: string; + output: string; + }; + String: { + input: string; + output: string; + }; + Boolean: { + input: boolean; + output: boolean; + }; + Int: { + input: number; + output: number; + }; + Float: { + input: number; + output: number; + }; + /** A (potentially binary) string encoded using base64. */ + Base64String: { + input: any; + output: any; + }; + /** + * Represents non-fractional signed whole numeric values. Since the value may + * exceed the size of a 32-bit integer, it's encoded as a string. + */ + BigInt: { + input: any; + output: any; + }; + /** An ISO-8601 encoded date string. */ + Date: { + input: any; + output: any; + }; + /** An ISO-8601 encoded UTC date string. */ + DateTime: { + input: any; + output: any; + }; + /** A Git object ID. */ + GitObjectID: { + input: any; + output: any; + }; + /** A fully qualified reference name (e.g. `refs/heads/master`). */ + GitRefname: { + input: any; + output: any; + }; + /** Git SSH string */ + GitSSHRemote: { + input: any; + output: any; + }; + /** An ISO-8601 encoded date string. Unlike the DateTime type, GitTimestamp is not converted in UTC. */ + GitTimestamp: { + input: any; + output: any; + }; + /** A string containing HTML code. */ + HTML: { + input: any; + output: any; + }; + /** An ISO-8601 encoded UTC date string with millisecond precision. */ + PreciseDateTime: { + input: any; + output: any; + }; + /** An RFC 3986, RFC 3987, and RFC 6570 (level 4) compliant URI string. */ + URI: { + input: any; + output: any; + }; + /** A valid x509 certificate string */ + X509Certificate: { + input: any; + output: any; + }; +}; +/** Autogenerated input type of AbortQueuedMigrations */ +export type AbortQueuedMigrationsInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the organization that is running the migrations. */ + ownerId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AbortQueuedMigrations. */ +export type AbortQueuedMigrationsPayload = { + __typename?: 'AbortQueuedMigrationsPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** Did the operation succeed? */ + success?: Maybe; +}; +/** Autogenerated input type of AbortRepositoryMigration */ +export type AbortRepositoryMigrationInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the migration to be aborted. */ + migrationId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AbortRepositoryMigration. */ +export type AbortRepositoryMigrationPayload = { + __typename?: 'AbortRepositoryMigrationPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** Did the operation succeed? */ + success?: Maybe; +}; +/** Autogenerated input type of AcceptEnterpriseAdministratorInvitation */ +export type AcceptEnterpriseAdministratorInvitationInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The id of the invitation being accepted */ + invitationId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AcceptEnterpriseAdministratorInvitation. */ +export type AcceptEnterpriseAdministratorInvitationPayload = { + __typename?: 'AcceptEnterpriseAdministratorInvitationPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The invitation that was accepted. */ + invitation?: Maybe; + /** A message confirming the result of accepting an administrator invitation. */ + message?: Maybe; +}; +/** Autogenerated input type of AcceptEnterpriseMemberInvitation */ +export type AcceptEnterpriseMemberInvitationInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The id of the invitation being accepted */ + invitationId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AcceptEnterpriseMemberInvitation. */ +export type AcceptEnterpriseMemberInvitationPayload = { + __typename?: 'AcceptEnterpriseMemberInvitationPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The invitation that was accepted. */ + invitation?: Maybe; + /** A message confirming the result of accepting an unaffiliated member invitation. */ + message?: Maybe; +}; +/** Autogenerated input type of AcceptTopicSuggestion */ +export type AcceptTopicSuggestionInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** + * The name of the suggested topic. + * + * **Upcoming Change on 2024-04-01 UTC** + * **Description:** `name` will be removed. + * **Reason:** Suggested topics are no longer supported + */ + name?: InputMaybe; + /** + * The Node ID of the repository. + * + * **Upcoming Change on 2024-04-01 UTC** + * **Description:** `repositoryId` will be removed. + * **Reason:** Suggested topics are no longer supported + */ + repositoryId?: InputMaybe; +}; +/** Autogenerated return type of AcceptTopicSuggestion. */ +export type AcceptTopicSuggestionPayload = { + __typename?: 'AcceptTopicSuggestionPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** + * The accepted topic. + * @deprecated Suggested topics are no longer supported Removal on 2024-04-01 UTC. + */ + topic?: Maybe; +}; +/** Represents an object which can take actions on GitHub. Typically a User or Bot. */ +export type Actor = { + /** A URL pointing to the actor's public avatar. */ + avatarUrl: Scalars['URI']['output']; + /** The username of the actor. */ + login: Scalars['String']['output']; + /** The HTTP path for this actor. */ + resourcePath: Scalars['URI']['output']; + /** The HTTP URL for this actor. */ + url: Scalars['URI']['output']; +}; +/** Represents an object which can take actions on GitHub. Typically a User or Bot. */ +export type ActorAvatarUrlArgs = { + size?: InputMaybe; +}; +/** Location information for an actor */ +export type ActorLocation = { + __typename?: 'ActorLocation'; + /** City */ + city?: Maybe; + /** Country name */ + country?: Maybe; + /** Country code */ + countryCode?: Maybe; + /** Region name */ + region?: Maybe; + /** Region or state code */ + regionCode?: Maybe; +}; +/** The actor's type. */ +export declare enum ActorType { + /** Indicates a team actor. */ + Team = "TEAM", + /** Indicates a user actor. */ + User = "USER" +} +/** Autogenerated input type of AddAssigneesToAssignable */ +export type AddAssigneesToAssignableInput = { + /** The id of the assignable object to add assignees to. */ + assignableId: Scalars['ID']['input']; + /** The id of users to add as assignees. */ + assigneeIds: Array; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; +}; +/** Autogenerated return type of AddAssigneesToAssignable. */ +export type AddAssigneesToAssignablePayload = { + __typename?: 'AddAssigneesToAssignablePayload'; + /** The item that was assigned. */ + assignable?: Maybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; +}; +/** Autogenerated input type of AddComment */ +export type AddCommentInput = { + /** The contents of the comment. */ + body: Scalars['String']['input']; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the subject to modify. */ + subjectId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddComment. */ +export type AddCommentPayload = { + __typename?: 'AddCommentPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The edge from the subject's comment connection. */ + commentEdge?: Maybe; + /** The subject */ + subject?: Maybe; + /** The edge from the subject's timeline connection. */ + timelineEdge?: Maybe; +}; +/** Autogenerated input type of AddDiscussionComment */ +export type AddDiscussionCommentInput = { + /** The contents of the comment. */ + body: Scalars['String']['input']; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the discussion to comment on. */ + discussionId: Scalars['ID']['input']; + /** The Node ID of the discussion comment within this discussion to reply to. */ + replyToId?: InputMaybe; +}; +/** Autogenerated return type of AddDiscussionComment. */ +export type AddDiscussionCommentPayload = { + __typename?: 'AddDiscussionCommentPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The newly created discussion comment. */ + comment?: Maybe; +}; +/** Autogenerated input type of AddDiscussionPollVote */ +export type AddDiscussionPollVoteInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the discussion poll option to vote for. */ + pollOptionId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddDiscussionPollVote. */ +export type AddDiscussionPollVotePayload = { + __typename?: 'AddDiscussionPollVotePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The poll option that a vote was added to. */ + pollOption?: Maybe; +}; +/** Autogenerated input type of AddEnterpriseOrganizationMember */ +export type AddEnterpriseOrganizationMemberInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the enterprise which owns the organization. */ + enterpriseId: Scalars['ID']['input']; + /** The ID of the organization the users will be added to. */ + organizationId: Scalars['ID']['input']; + /** The role to assign the users in the organization */ + role?: InputMaybe; + /** The IDs of the enterprise members to add. */ + userIds: Array; +}; +/** Autogenerated return type of AddEnterpriseOrganizationMember. */ +export type AddEnterpriseOrganizationMemberPayload = { + __typename?: 'AddEnterpriseOrganizationMemberPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The users who were added to the organization. */ + users?: Maybe>; +}; +/** Autogenerated input type of AddEnterpriseSupportEntitlement */ +export type AddEnterpriseSupportEntitlementInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the Enterprise which the admin belongs to. */ + enterpriseId: Scalars['ID']['input']; + /** The login of a member who will receive the support entitlement. */ + login: Scalars['String']['input']; +}; +/** Autogenerated return type of AddEnterpriseSupportEntitlement. */ +export type AddEnterpriseSupportEntitlementPayload = { + __typename?: 'AddEnterpriseSupportEntitlementPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** A message confirming the result of adding the support entitlement. */ + message?: Maybe; +}; +/** Autogenerated input type of AddLabelsToLabelable */ +export type AddLabelsToLabelableInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ids of the labels to add. */ + labelIds: Array; + /** The id of the labelable object to add labels to. */ + labelableId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddLabelsToLabelable. */ +export type AddLabelsToLabelablePayload = { + __typename?: 'AddLabelsToLabelablePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The item that was labeled. */ + labelable?: Maybe; +}; +/** Autogenerated input type of AddProjectCard */ +export type AddProjectCardInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The content of the card. Must be a member of the ProjectCardItem union */ + contentId?: InputMaybe; + /** The note on the card. */ + note?: InputMaybe; + /** The Node ID of the ProjectColumn. */ + projectColumnId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddProjectCard. */ +export type AddProjectCardPayload = { + __typename?: 'AddProjectCardPayload'; + /** The edge from the ProjectColumn's card connection. */ + cardEdge?: Maybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The ProjectColumn */ + projectColumn?: Maybe; +}; +/** Autogenerated input type of AddProjectColumn */ +export type AddProjectColumnInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The name of the column. */ + name: Scalars['String']['input']; + /** The Node ID of the project. */ + projectId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddProjectColumn. */ +export type AddProjectColumnPayload = { + __typename?: 'AddProjectColumnPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The edge from the project's column connection. */ + columnEdge?: Maybe; + /** The project */ + project?: Maybe; +}; +/** Autogenerated input type of AddProjectV2DraftIssue */ +export type AddProjectV2DraftIssueInput = { + /** The IDs of the assignees of the draft issue. */ + assigneeIds?: InputMaybe>; + /** The body of the draft issue. */ + body?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the Project to add the draft issue to. */ + projectId: Scalars['ID']['input']; + /** + * The title of the draft issue. A project item can also be created by providing + * the URL of an Issue or Pull Request if you have access. + */ + title: Scalars['String']['input']; +}; +/** Autogenerated return type of AddProjectV2DraftIssue. */ +export type AddProjectV2DraftIssuePayload = { + __typename?: 'AddProjectV2DraftIssuePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The draft issue added to the project. */ + projectItem?: Maybe; +}; +/** Autogenerated input type of AddProjectV2ItemById */ +export type AddProjectV2ItemByIdInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The id of the Issue or Pull Request to add. */ + contentId: Scalars['ID']['input']; + /** The ID of the Project to add the item to. */ + projectId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddProjectV2ItemById. */ +export type AddProjectV2ItemByIdPayload = { + __typename?: 'AddProjectV2ItemByIdPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The item added to the project. */ + item?: Maybe; +}; +/** Autogenerated input type of AddPullRequestReviewComment */ +export type AddPullRequestReviewCommentInput = { + /** + * The text of the comment. This field is required + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `body` will be removed. use addPullRequestReviewThread or addPullRequestReviewThreadReply instead + * **Reason:** We are deprecating the addPullRequestReviewComment mutation + */ + body?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** + * The SHA of the commit to comment on. + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `commitOID` will be removed. use addPullRequestReviewThread or addPullRequestReviewThreadReply instead + * **Reason:** We are deprecating the addPullRequestReviewComment mutation + */ + commitOID?: InputMaybe; + /** + * The comment id to reply to. + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `inReplyTo` will be removed. use addPullRequestReviewThread or addPullRequestReviewThreadReply instead + * **Reason:** We are deprecating the addPullRequestReviewComment mutation + */ + inReplyTo?: InputMaybe; + /** + * The relative path of the file to comment on. + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `path` will be removed. use addPullRequestReviewThread or addPullRequestReviewThreadReply instead + * **Reason:** We are deprecating the addPullRequestReviewComment mutation + */ + path?: InputMaybe; + /** + * The line index in the diff to comment on. + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `position` will be removed. use addPullRequestReviewThread or addPullRequestReviewThreadReply instead + * **Reason:** We are deprecating the addPullRequestReviewComment mutation + */ + position?: InputMaybe; + /** + * The node ID of the pull request reviewing + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `pullRequestId` will be removed. use + * addPullRequestReviewThread or addPullRequestReviewThreadReply instead + * **Reason:** We are deprecating the addPullRequestReviewComment mutation + */ + pullRequestId?: InputMaybe; + /** + * The Node ID of the review to modify. + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `pullRequestReviewId` will be removed. use + * addPullRequestReviewThread or addPullRequestReviewThreadReply instead + * **Reason:** We are deprecating the addPullRequestReviewComment mutation + */ + pullRequestReviewId?: InputMaybe; +}; +/** Autogenerated return type of AddPullRequestReviewComment. */ +export type AddPullRequestReviewCommentPayload = { + __typename?: 'AddPullRequestReviewCommentPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The newly created comment. */ + comment?: Maybe; + /** The edge from the review's comment connection. */ + commentEdge?: Maybe; +}; +/** Autogenerated input type of AddPullRequestReview */ +export type AddPullRequestReviewInput = { + /** The contents of the review body comment. */ + body?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** + * The review line comments. + * + * **Upcoming Change on 2023-10-01 UTC** + * **Description:** `comments` will be removed. use the `threads` argument instead + * **Reason:** We are deprecating comment fields that use diff-relative positioning + */ + comments?: InputMaybe>>; + /** The commit OID the review pertains to. */ + commitOID?: InputMaybe; + /** The event to perform on the pull request review. */ + event?: InputMaybe; + /** The Node ID of the pull request to modify. */ + pullRequestId: Scalars['ID']['input']; + /** The review line comment threads. */ + threads?: InputMaybe>>; +}; +/** Autogenerated return type of AddPullRequestReview. */ +export type AddPullRequestReviewPayload = { + __typename?: 'AddPullRequestReviewPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The newly created pull request review. */ + pullRequestReview?: Maybe; + /** The edge from the pull request's review connection. */ + reviewEdge?: Maybe; +}; +/** Autogenerated input type of AddPullRequestReviewThread */ +export type AddPullRequestReviewThreadInput = { + /** Body of the thread's first comment. */ + body: Scalars['String']['input']; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** + * The line of the blob to which the thread refers, required for line-level + * threads. The end of the line range for multi-line comments. + */ + line?: InputMaybe; + /** Path to the file being commented on. */ + path: Scalars['String']['input']; + /** The node ID of the pull request reviewing */ + pullRequestId?: InputMaybe; + /** The Node ID of the review to modify. */ + pullRequestReviewId?: InputMaybe; + /** 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. */ + side?: InputMaybe; + /** The first line of the range to which the comment refers. */ + startLine?: InputMaybe; + /** The side of the diff on which the start line resides. */ + startSide?: InputMaybe; + /** The level at which the comments in the corresponding thread are targeted, can be a diff line or a file */ + subjectType?: InputMaybe; +}; +/** Autogenerated return type of AddPullRequestReviewThread. */ +export type AddPullRequestReviewThreadPayload = { + __typename?: 'AddPullRequestReviewThreadPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The newly created thread. */ + thread?: Maybe; +}; +/** Autogenerated input type of AddPullRequestReviewThreadReply */ +export type AddPullRequestReviewThreadReplyInput = { + /** The text of the reply. */ + body: Scalars['String']['input']; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the pending review to which the reply will belong. */ + pullRequestReviewId?: InputMaybe; + /** The Node ID of the thread to which this reply is being written. */ + pullRequestReviewThreadId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddPullRequestReviewThreadReply. */ +export type AddPullRequestReviewThreadReplyPayload = { + __typename?: 'AddPullRequestReviewThreadReplyPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The newly created reply. */ + comment?: Maybe; +}; +/** Autogenerated input type of AddReaction */ +export type AddReactionInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The name of the emoji to react with. */ + content: ReactionContent; + /** The Node ID of the subject to modify. */ + subjectId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddReaction. */ +export type AddReactionPayload = { + __typename?: 'AddReactionPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The reaction object. */ + reaction?: Maybe; + /** The reaction groups for the subject. */ + reactionGroups?: Maybe>; + /** The reactable subject. */ + subject?: Maybe; +}; +/** Autogenerated input type of AddStar */ +export type AddStarInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Starrable ID to star. */ + starrableId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddStar. */ +export type AddStarPayload = { + __typename?: 'AddStarPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The starrable. */ + starrable?: Maybe; +}; +/** Autogenerated input type of AddUpvote */ +export type AddUpvoteInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the discussion or comment to upvote. */ + subjectId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddUpvote. */ +export type AddUpvotePayload = { + __typename?: 'AddUpvotePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The votable subject. */ + subject?: Maybe; +}; +/** Autogenerated input type of AddVerifiableDomain */ +export type AddVerifiableDomainInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The URL of the domain */ + domain: Scalars['URI']['input']; + /** The ID of the owner to add the domain to */ + ownerId: Scalars['ID']['input']; +}; +/** Autogenerated return type of AddVerifiableDomain. */ +export type AddVerifiableDomainPayload = { + __typename?: 'AddVerifiableDomainPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The verifiable domain that was added. */ + domain?: Maybe; +}; +/** Represents an 'added_to_merge_queue' event on a given pull request. */ +export type AddedToMergeQueueEvent = Node & { + __typename?: 'AddedToMergeQueueEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The user who added this Pull Request to the merge queue */ + enqueuer?: Maybe; + /** The Node ID of the AddedToMergeQueueEvent object */ + id: Scalars['ID']['output']; + /** The merge queue where this pull request was added to. */ + mergeQueue?: Maybe; + /** PullRequest referenced by event. */ + pullRequest?: Maybe; +}; +/** Represents a 'added_to_project' event on a given issue or pull request. */ +export type AddedToProjectEvent = Node & { + __typename?: 'AddedToProjectEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The Node ID of the AddedToProjectEvent object */ + id: Scalars['ID']['output']; + /** Project referenced by event. */ + project?: Maybe; + /** Project card referenced by this project event. */ + projectCard?: Maybe; + /** Column name referenced by this project event. */ + projectColumnName: Scalars['String']['output']; +}; +/** Represents an announcement banner. */ +export type AnnouncementBanner = { + /** The text of the announcement */ + announcement?: Maybe; + /** The date the announcement was created */ + announcementCreatedAt?: Maybe; + /** The expiration date of the announcement, if any */ + announcementExpiresAt?: Maybe; + /** Whether the announcement can be dismissed by the user */ + announcementUserDismissible?: Maybe; +}; +/** A GitHub App. */ +export type App = Node & { + __typename?: 'App'; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The description of the app. */ + description?: Maybe; + /** The Node ID of the App object */ + id: Scalars['ID']['output']; + /** The IP addresses of the app. */ + ipAllowListEntries: IpAllowListEntryConnection; + /** The hex color code, without the leading '#', for the logo background. */ + logoBackgroundColor: Scalars['String']['output']; + /** A URL pointing to the app's logo. */ + logoUrl: Scalars['URI']['output']; + /** The name of the app. */ + name: Scalars['String']['output']; + /** A slug based on the name of the app for use in URLs. */ + slug: Scalars['String']['output']; + /** Identifies the date and time when the object was last updated. */ + updatedAt: Scalars['DateTime']['output']; + /** The URL to the app's homepage. */ + url: Scalars['URI']['output']; +}; +/** A GitHub App. */ +export type AppIpAllowListEntriesArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** A GitHub App. */ +export type AppLogoUrlArgs = { + size?: InputMaybe; +}; +/** Autogenerated input type of ApproveDeployments */ +export type ApproveDeploymentsInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** Optional comment for approving deployments */ + comment?: InputMaybe; + /** The ids of environments to reject deployments */ + environmentIds: Array; + /** The node ID of the workflow run containing the pending deployments. */ + workflowRunId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ApproveDeployments. */ +export type ApproveDeploymentsPayload = { + __typename?: 'ApproveDeploymentsPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The affected deployments. */ + deployments?: Maybe>; +}; +/** Autogenerated input type of ApproveVerifiableDomain */ +export type ApproveVerifiableDomainInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the verifiable domain to approve. */ + id: Scalars['ID']['input']; +}; +/** Autogenerated return type of ApproveVerifiableDomain. */ +export type ApproveVerifiableDomainPayload = { + __typename?: 'ApproveVerifiableDomainPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The verifiable domain that was approved. */ + domain?: Maybe; +}; +/** Autogenerated input type of ArchiveProjectV2Item */ +export type ArchiveProjectV2ItemInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the ProjectV2Item to archive. */ + itemId: Scalars['ID']['input']; + /** The ID of the Project to archive the item from. */ + projectId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ArchiveProjectV2Item. */ +export type ArchiveProjectV2ItemPayload = { + __typename?: 'ArchiveProjectV2ItemPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The item archived from the project. */ + item?: Maybe; +}; +/** Autogenerated input type of ArchiveRepository */ +export type ArchiveRepositoryInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the repository to mark as archived. */ + repositoryId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ArchiveRepository. */ +export type ArchiveRepositoryPayload = { + __typename?: 'ArchiveRepositoryPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The repository that was marked as archived. */ + repository?: Maybe; +}; +/** An object that can have users assigned to it. */ +export type Assignable = { + /** A list of Users assigned to this object. */ + assignees: UserConnection; +}; +/** An object that can have users assigned to it. */ +export type AssignableAssigneesArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** Represents an 'assigned' event on any assignable object. */ +export type AssignedEvent = Node & { + __typename?: 'AssignedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the assignable associated with the event. */ + assignable: Assignable; + /** Identifies the user or mannequin that was assigned. */ + assignee?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the AssignedEvent object */ + id: Scalars['ID']['output']; + /** + * Identifies the user who was assigned. + * @deprecated Assignees can now be mannequins. Use the `assignee` field instead. Removal on 2020-01-01 UTC. + */ + user?: Maybe; +}; +/** Types that can be assigned to issues. */ +export type Assignee = Bot | Mannequin | Organization | User; +/** An entry in the audit log. */ +export type AuditEntry = { + /** The action name */ + action: Scalars['String']['output']; + /** The user who initiated the action */ + actor?: Maybe; + /** The IP address of the actor */ + actorIp?: Maybe; + /** A readable representation of the actor's location */ + actorLocation?: Maybe; + /** The username of the user who initiated the action */ + actorLogin?: Maybe; + /** The HTTP path for the actor. */ + actorResourcePath?: Maybe; + /** The HTTP URL for the actor. */ + actorUrl?: Maybe; + /** The time the action was initiated */ + createdAt: Scalars['PreciseDateTime']['output']; + /** The corresponding operation type for the action */ + operationType?: Maybe; + /** The user affected by the action */ + user?: Maybe; + /** For actions involving two users, the actor is the initiator and the user is the affected user. */ + userLogin?: Maybe; + /** The HTTP path for the user. */ + userResourcePath?: Maybe; + /** The HTTP URL for the user. */ + userUrl?: Maybe; +}; +/** Types that can initiate an audit log event. */ +export type AuditEntryActor = Bot | Organization | User; +/** Ordering options for Audit Log connections. */ +export type AuditLogOrder = { + /** The ordering direction. */ + direction?: InputMaybe; + /** The field to order Audit Logs by. */ + field?: InputMaybe; +}; +/** Properties by which Audit Log connections can be ordered. */ +export declare enum AuditLogOrderField { + /** Order audit log entries by timestamp */ + CreatedAt = "CREATED_AT" +} +/** Represents a 'auto_merge_disabled' event on a given pull request. */ +export type AutoMergeDisabledEvent = Node & { + __typename?: 'AutoMergeDisabledEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The user who disabled auto-merge for this Pull Request */ + disabler?: Maybe; + /** The Node ID of the AutoMergeDisabledEvent object */ + id: Scalars['ID']['output']; + /** PullRequest referenced by event */ + pullRequest?: Maybe; + /** The reason auto-merge was disabled */ + reason?: Maybe; + /** The reason_code relating to why auto-merge was disabled */ + reasonCode?: Maybe; +}; +/** Represents a 'auto_merge_enabled' event on a given pull request. */ +export type AutoMergeEnabledEvent = Node & { + __typename?: 'AutoMergeEnabledEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The user who enabled auto-merge for this Pull Request */ + enabler?: Maybe; + /** The Node ID of the AutoMergeEnabledEvent object */ + id: Scalars['ID']['output']; + /** PullRequest referenced by event. */ + pullRequest?: Maybe; +}; +/** Represents an auto-merge request for a pull request */ +export type AutoMergeRequest = { + __typename?: 'AutoMergeRequest'; + /** The email address of the author of this auto-merge request. */ + authorEmail?: Maybe; + /** + * 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. + */ + commitBody?: Maybe; + /** + * 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 + */ + commitHeadline?: Maybe; + /** When was this auto-merge request was enabled. */ + enabledAt?: Maybe; + /** The actor who created the auto-merge request. */ + enabledBy?: Maybe; + /** + * 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. + */ + mergeMethod: PullRequestMergeMethod; + /** The pull request that this auto-merge request is set against. */ + pullRequest: PullRequest; +}; +/** Represents a 'auto_rebase_enabled' event on a given pull request. */ +export type AutoRebaseEnabledEvent = Node & { + __typename?: 'AutoRebaseEnabledEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The user who enabled auto-merge (rebase) for this Pull Request */ + enabler?: Maybe; + /** The Node ID of the AutoRebaseEnabledEvent object */ + id: Scalars['ID']['output']; + /** PullRequest referenced by event. */ + pullRequest?: Maybe; +}; +/** Represents a 'auto_squash_enabled' event on a given pull request. */ +export type AutoSquashEnabledEvent = Node & { + __typename?: 'AutoSquashEnabledEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The user who enabled auto-merge (squash) for this Pull Request */ + enabler?: Maybe; + /** The Node ID of the AutoSquashEnabledEvent object */ + id: Scalars['ID']['output']; + /** PullRequest referenced by event. */ + pullRequest?: Maybe; +}; +/** Represents a 'automatic_base_change_failed' event on a given pull request. */ +export type AutomaticBaseChangeFailedEvent = Node & { + __typename?: 'AutomaticBaseChangeFailedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the AutomaticBaseChangeFailedEvent object */ + id: Scalars['ID']['output']; + /** The new base for this PR */ + newBase: Scalars['String']['output']; + /** The old base for this PR */ + oldBase: Scalars['String']['output']; + /** PullRequest referenced by event. */ + pullRequest: PullRequest; +}; +/** Represents a 'automatic_base_change_succeeded' event on a given pull request. */ +export type AutomaticBaseChangeSucceededEvent = Node & { + __typename?: 'AutomaticBaseChangeSucceededEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the AutomaticBaseChangeSucceededEvent object */ + id: Scalars['ID']['output']; + /** The new base for this PR */ + newBase: Scalars['String']['output']; + /** The old base for this PR */ + oldBase: Scalars['String']['output']; + /** PullRequest referenced by event. */ + pullRequest: PullRequest; +}; +/** Represents a 'base_ref_changed' event on a given issue or pull request. */ +export type BaseRefChangedEvent = Node & { + __typename?: 'BaseRefChangedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Identifies the name of the base ref for the pull request after it was changed. */ + currentRefName: Scalars['String']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The Node ID of the BaseRefChangedEvent object */ + id: Scalars['ID']['output']; + /** Identifies the name of the base ref for the pull request before it was changed. */ + previousRefName: Scalars['String']['output']; + /** PullRequest referenced by event. */ + pullRequest: PullRequest; +}; +/** Represents a 'base_ref_deleted' event on a given pull request. */ +export type BaseRefDeletedEvent = Node & { + __typename?: 'BaseRefDeletedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the name of the Ref associated with the `base_ref_deleted` event. */ + baseRefName?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the BaseRefDeletedEvent object */ + id: Scalars['ID']['output']; + /** PullRequest referenced by event. */ + pullRequest?: Maybe; +}; +/** Represents a 'base_ref_force_pushed' event on a given pull request. */ +export type BaseRefForcePushedEvent = Node & { + __typename?: 'BaseRefForcePushedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the after commit SHA for the 'base_ref_force_pushed' event. */ + afterCommit?: Maybe; + /** Identifies the before commit SHA for the 'base_ref_force_pushed' event. */ + beforeCommit?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the BaseRefForcePushedEvent object */ + id: Scalars['ID']['output']; + /** PullRequest referenced by event. */ + pullRequest: PullRequest; + /** Identifies the fully qualified ref name for the 'base_ref_force_pushed' event. */ + ref?: Maybe; +}; +/** Represents a Git blame. */ +export type Blame = { + __typename?: 'Blame'; + /** The list of ranges from a Git blame. */ + ranges: Array; +}; +/** Represents a range of information from a Git blame. */ +export type BlameRange = { + __typename?: 'BlameRange'; + /** + * 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. + */ + age: Scalars['Int']['output']; + /** Identifies the line author */ + commit: Commit; + /** The ending line for the range */ + endingLine: Scalars['Int']['output']; + /** The starting line for the range */ + startingLine: Scalars['Int']['output']; +}; +/** Represents a Git blob. */ +export type Blob = GitObject & Node & { + __typename?: 'Blob'; + /** An abbreviated version of the Git object ID */ + abbreviatedOid: Scalars['String']['output']; + /** Byte size of Blob object */ + byteSize: Scalars['Int']['output']; + /** The HTTP path for this Git object */ + commitResourcePath: Scalars['URI']['output']; + /** The HTTP URL for this Git object */ + commitUrl: Scalars['URI']['output']; + /** The Node ID of the Blob object */ + id: Scalars['ID']['output']; + /** Indicates whether the Blob is binary or text. Returns null if unable to determine the encoding. */ + isBinary?: Maybe; + /** Indicates whether the contents is truncated */ + isTruncated: Scalars['Boolean']['output']; + /** The Git object ID */ + oid: Scalars['GitObjectID']['output']; + /** The Repository the Git object belongs to */ + repository: Repository; + /** UTF8 text data or null if the Blob is binary */ + text?: Maybe; +}; +/** A special type of user which takes actions on behalf of GitHub Apps. */ +export type Bot = Actor & Node & UniformResourceLocatable & { + __typename?: 'Bot'; + /** A URL pointing to the GitHub App's public avatar. */ + avatarUrl: Scalars['URI']['output']; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The Node ID of the Bot object */ + id: Scalars['ID']['output']; + /** The username of the actor. */ + login: Scalars['String']['output']; + /** The HTTP path for this bot */ + resourcePath: Scalars['URI']['output']; + /** Identifies the date and time when the object was last updated. */ + updatedAt: Scalars['DateTime']['output']; + /** The HTTP URL for this bot */ + url: Scalars['URI']['output']; +}; +/** A special type of user which takes actions on behalf of GitHub Apps. */ +export type BotAvatarUrlArgs = { + size?: InputMaybe; +}; +/** Types which can be actors for `BranchActorAllowance` objects. */ +export type BranchActorAllowanceActor = App | Team | User; +/** Parameters to be used for the branch_name_pattern rule */ +export type BranchNamePatternParameters = { + __typename?: 'BranchNamePatternParameters'; + /** How this rule will appear to users. */ + name?: Maybe; + /** If true, the rule will fail if the pattern matches. */ + negate: Scalars['Boolean']['output']; + /** The operator to use for matching. */ + operator: Scalars['String']['output']; + /** The pattern to match with. */ + pattern: Scalars['String']['output']; +}; +/** Parameters to be used for the branch_name_pattern rule */ +export type BranchNamePatternParametersInput = { + /** How this rule will appear to users. */ + name?: InputMaybe; + /** If true, the rule will fail if the pattern matches. */ + negate?: InputMaybe; + /** The operator to use for matching. */ + operator: Scalars['String']['input']; + /** The pattern to match with. */ + pattern: Scalars['String']['input']; +}; +/** A branch protection rule. */ +export type BranchProtectionRule = Node & { + __typename?: 'BranchProtectionRule'; + /** Can this branch be deleted. */ + allowsDeletions: Scalars['Boolean']['output']; + /** Are force pushes allowed on this branch. */ + allowsForcePushes: Scalars['Boolean']['output']; + /** Is branch creation a protected operation. */ + blocksCreations: Scalars['Boolean']['output']; + /** A list of conflicts matching branches protection rule and other branch protection rules */ + branchProtectionRuleConflicts: BranchProtectionRuleConflictConnection; + /** A list of actors able to force push for this branch protection rule. */ + bypassForcePushAllowances: BypassForcePushAllowanceConnection; + /** A list of actors able to bypass PRs for this branch protection rule. */ + bypassPullRequestAllowances: BypassPullRequestAllowanceConnection; + /** The actor who created this branch protection rule. */ + creator?: Maybe; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** Will new commits pushed to matching branches dismiss pull request review approvals. */ + dismissesStaleReviews: Scalars['Boolean']['output']; + /** The Node ID of the BranchProtectionRule object */ + id: Scalars['ID']['output']; + /** Can admins override branch protection. */ + isAdminEnforced: Scalars['Boolean']['output']; + /** + * Whether users can pull changes from upstream when the branch is locked. Set to + * `true` to allow fork syncing. Set to `false` to prevent fork syncing. + */ + lockAllowsFetchAndMerge: Scalars['Boolean']['output']; + /** Whether to set the branch as read-only. If this is true, users will not be able to push to the branch. */ + lockBranch: Scalars['Boolean']['output']; + /** Repository refs that are protected by this rule */ + matchingRefs: RefConnection; + /** Identifies the protection rule pattern. */ + pattern: Scalars['String']['output']; + /** A list push allowances for this branch protection rule. */ + pushAllowances: PushAllowanceConnection; + /** The repository associated with this branch protection rule. */ + repository?: Maybe; + /** Whether the most recent push must be approved by someone other than the person who pushed it */ + requireLastPushApproval: Scalars['Boolean']['output']; + /** Number of approving reviews required to update matching branches. */ + requiredApprovingReviewCount?: Maybe; + /** List of required deployment environments that must be deployed successfully to update matching branches */ + requiredDeploymentEnvironments?: Maybe>>; + /** List of required status check contexts that must pass for commits to be accepted to matching branches. */ + requiredStatusCheckContexts?: Maybe>>; + /** List of required status checks that must pass for commits to be accepted to matching branches. */ + requiredStatusChecks?: Maybe>; + /** Are approving reviews required to update matching branches. */ + requiresApprovingReviews: Scalars['Boolean']['output']; + /** Are reviews from code owners required to update matching branches. */ + requiresCodeOwnerReviews: Scalars['Boolean']['output']; + /** Are commits required to be signed. */ + requiresCommitSignatures: Scalars['Boolean']['output']; + /** Are conversations required to be resolved before merging. */ + requiresConversationResolution: Scalars['Boolean']['output']; + /** Does this branch require deployment to specific environments before merging */ + requiresDeployments: Scalars['Boolean']['output']; + /** Are merge commits prohibited from being pushed to this branch. */ + requiresLinearHistory: Scalars['Boolean']['output']; + /** Are status checks required to update matching branches. */ + requiresStatusChecks: Scalars['Boolean']['output']; + /** Are branches required to be up to date before merging. */ + requiresStrictStatusChecks: Scalars['Boolean']['output']; + /** Is pushing to matching branches restricted. */ + restrictsPushes: Scalars['Boolean']['output']; + /** Is dismissal of pull request reviews restricted. */ + restrictsReviewDismissals: Scalars['Boolean']['output']; + /** A list review dismissal allowances for this branch protection rule. */ + reviewDismissalAllowances: ReviewDismissalAllowanceConnection; +}; +/** A branch protection rule. */ +export type BranchProtectionRuleBranchProtectionRuleConflictsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A branch protection rule. */ +export type BranchProtectionRuleBypassForcePushAllowancesArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A branch protection rule. */ +export type BranchProtectionRuleBypassPullRequestAllowancesArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A branch protection rule. */ +export type BranchProtectionRuleMatchingRefsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + query?: InputMaybe; +}; +/** A branch protection rule. */ +export type BranchProtectionRulePushAllowancesArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A branch protection rule. */ +export type BranchProtectionRuleReviewDismissalAllowancesArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A conflict between two branch protection rules. */ +export type BranchProtectionRuleConflict = { + __typename?: 'BranchProtectionRuleConflict'; + /** Identifies the branch protection rule. */ + branchProtectionRule?: Maybe; + /** Identifies the conflicting branch protection rule. */ + conflictingBranchProtectionRule?: Maybe; + /** Identifies the branch ref that has conflicting rules */ + ref?: Maybe; +}; +/** The connection type for BranchProtectionRuleConflict. */ +export type BranchProtectionRuleConflictConnection = { + __typename?: 'BranchProtectionRuleConflictConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type BranchProtectionRuleConflictEdge = { + __typename?: 'BranchProtectionRuleConflictEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** The connection type for BranchProtectionRule. */ +export type BranchProtectionRuleConnection = { + __typename?: 'BranchProtectionRuleConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type BranchProtectionRuleEdge = { + __typename?: 'BranchProtectionRuleEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** + * Information about a sponsorship to make for a user or organization with a GitHub + * Sponsors profile, as part of sponsoring many users or organizations at once. + */ +export type BulkSponsorship = { + /** The amount to pay to the sponsorable in US dollars. Valid values: 1-12000. */ + amount: Scalars['Int']['input']; + /** The ID of the user or organization who is receiving the sponsorship. Required if sponsorableLogin is not given. */ + sponsorableId?: InputMaybe; + /** The username of the user or organization who is receiving the sponsorship. Required if sponsorableId is not given. */ + sponsorableLogin?: InputMaybe; +}; +/** Types that can represent a repository ruleset bypass actor. */ +export type BypassActor = App | Team; +/** A user, team, or app who has the ability to bypass a force push requirement on a protected branch. */ +export type BypassForcePushAllowance = Node & { + __typename?: 'BypassForcePushAllowance'; + /** The actor that can force push. */ + actor?: Maybe; + /** Identifies the branch protection rule associated with the allowed user, team, or app. */ + branchProtectionRule?: Maybe; + /** The Node ID of the BypassForcePushAllowance object */ + id: Scalars['ID']['output']; +}; +/** The connection type for BypassForcePushAllowance. */ +export type BypassForcePushAllowanceConnection = { + __typename?: 'BypassForcePushAllowanceConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type BypassForcePushAllowanceEdge = { + __typename?: 'BypassForcePushAllowanceEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** A user, team, or app who has the ability to bypass a pull request requirement on a protected branch. */ +export type BypassPullRequestAllowance = Node & { + __typename?: 'BypassPullRequestAllowance'; + /** The actor that can bypass. */ + actor?: Maybe; + /** Identifies the branch protection rule associated with the allowed user, team, or app. */ + branchProtectionRule?: Maybe; + /** The Node ID of the BypassPullRequestAllowance object */ + id: Scalars['ID']['output']; +}; +/** The connection type for BypassPullRequestAllowance. */ +export type BypassPullRequestAllowanceConnection = { + __typename?: 'BypassPullRequestAllowanceConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type BypassPullRequestAllowanceEdge = { + __typename?: 'BypassPullRequestAllowanceEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** The Common Vulnerability Scoring System */ +export type Cvss = { + __typename?: 'CVSS'; + /** The CVSS score associated with this advisory */ + score: Scalars['Float']['output']; + /** The CVSS vector string associated with this advisory */ + vectorString?: Maybe; +}; +/** A common weakness enumeration */ +export type Cwe = Node & { + __typename?: 'CWE'; + /** The id of the CWE */ + cweId: Scalars['String']['output']; + /** A detailed description of this CWE */ + description: Scalars['String']['output']; + /** The Node ID of the CWE object */ + id: Scalars['ID']['output']; + /** The name of this CWE */ + name: Scalars['String']['output']; +}; +/** The connection type for CWE. */ +export type CweConnection = { + __typename?: 'CWEConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type CweEdge = { + __typename?: 'CWEEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** Autogenerated input type of CancelEnterpriseAdminInvitation */ +export type CancelEnterpriseAdminInvitationInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the pending enterprise administrator invitation. */ + invitationId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CancelEnterpriseAdminInvitation. */ +export type CancelEnterpriseAdminInvitationPayload = { + __typename?: 'CancelEnterpriseAdminInvitationPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The invitation that was canceled. */ + invitation?: Maybe; + /** A message confirming the result of canceling an administrator invitation. */ + message?: Maybe; +}; +/** Autogenerated input type of CancelEnterpriseMemberInvitation */ +export type CancelEnterpriseMemberInvitationInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the pending enterprise member invitation. */ + invitationId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CancelEnterpriseMemberInvitation. */ +export type CancelEnterpriseMemberInvitationPayload = { + __typename?: 'CancelEnterpriseMemberInvitationPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The invitation that was canceled. */ + invitation?: Maybe; + /** A message confirming the result of canceling an member invitation. */ + message?: Maybe; +}; +/** Autogenerated input type of CancelSponsorship */ +export type CancelSponsorshipInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** + * The ID of the user or organization who is acting as the sponsor, paying for + * the sponsorship. Required if sponsorLogin is not given. + */ + sponsorId?: InputMaybe; + /** + * The username of the user or organization who is acting as the sponsor, paying + * for the sponsorship. Required if sponsorId is not given. + */ + sponsorLogin?: InputMaybe; + /** The ID of the user or organization who is receiving the sponsorship. Required if sponsorableLogin is not given. */ + sponsorableId?: InputMaybe; + /** The username of the user or organization who is receiving the sponsorship. Required if sponsorableId is not given. */ + sponsorableLogin?: InputMaybe; +}; +/** Autogenerated return type of CancelSponsorship. */ +export type CancelSponsorshipPayload = { + __typename?: 'CancelSponsorshipPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The tier that was being used at the time of cancellation. */ + sponsorsTier?: Maybe; +}; +/** Autogenerated input type of ChangeUserStatus */ +export type ChangeUserStatusInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The emoji to represent your status. Can either be a native Unicode emoji or an emoji name with colons, e.g., :grinning:. */ + emoji?: InputMaybe; + /** If set, the user status will not be shown after this date. */ + expiresAt?: InputMaybe; + /** Whether this status should indicate you are not fully available on GitHub, e.g., you are away. */ + limitedAvailability?: InputMaybe; + /** A short description of your current status. */ + message?: InputMaybe; + /** + * The ID of the organization whose members will be allowed to see the status. If + * omitted, the status will be publicly visible. + */ + organizationId?: InputMaybe; +}; +/** Autogenerated return type of ChangeUserStatus. */ +export type ChangeUserStatusPayload = { + __typename?: 'ChangeUserStatusPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** Your updated status. */ + status?: Maybe; +}; +/** A single check annotation. */ +export type CheckAnnotation = { + __typename?: 'CheckAnnotation'; + /** The annotation's severity level. */ + annotationLevel?: Maybe; + /** The path to the file that this annotation was made on. */ + blobUrl: Scalars['URI']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The position of this annotation. */ + location: CheckAnnotationSpan; + /** The annotation's message. */ + message: Scalars['String']['output']; + /** The path that this annotation was made on. */ + path: Scalars['String']['output']; + /** Additional information about the annotation. */ + rawDetails?: Maybe; + /** The annotation's title */ + title?: Maybe; +}; +/** The connection type for CheckAnnotation. */ +export type CheckAnnotationConnection = { + __typename?: 'CheckAnnotationConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** Information from a check run analysis to specific lines of code. */ +export type CheckAnnotationData = { + /** Represents an annotation's information level */ + annotationLevel: CheckAnnotationLevel; + /** The location of the annotation */ + location: CheckAnnotationRange; + /** A short description of the feedback for these lines of code. */ + message: Scalars['String']['input']; + /** The path of the file to add an annotation to. */ + path: Scalars['String']['input']; + /** Details about this annotation. */ + rawDetails?: InputMaybe; + /** The title that represents the annotation. */ + title?: InputMaybe; +}; +/** An edge in a connection. */ +export type CheckAnnotationEdge = { + __typename?: 'CheckAnnotationEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** Represents an annotation's information level. */ +export declare enum CheckAnnotationLevel { + /** An annotation indicating an inescapable error. */ + Failure = "FAILURE", + /** An annotation indicating some information. */ + Notice = "NOTICE", + /** An annotation indicating an ignorable error. */ + Warning = "WARNING" +} +/** A character position in a check annotation. */ +export type CheckAnnotationPosition = { + __typename?: 'CheckAnnotationPosition'; + /** Column number (1 indexed). */ + column?: Maybe; + /** Line number (1 indexed). */ + line: Scalars['Int']['output']; +}; +/** Information from a check run analysis to specific lines of code. */ +export type CheckAnnotationRange = { + /** The ending column of the range. */ + endColumn?: InputMaybe; + /** The ending line of the range. */ + endLine: Scalars['Int']['input']; + /** The starting column of the range. */ + startColumn?: InputMaybe; + /** The starting line of the range. */ + startLine: Scalars['Int']['input']; +}; +/** An inclusive pair of positions for a check annotation. */ +export type CheckAnnotationSpan = { + __typename?: 'CheckAnnotationSpan'; + /** End position (inclusive). */ + end: CheckAnnotationPosition; + /** Start position (inclusive). */ + start: CheckAnnotationPosition; +}; +/** The possible states for a check suite or run conclusion. */ +export declare enum CheckConclusionState { + /** The check suite or run requires action. */ + ActionRequired = "ACTION_REQUIRED", + /** The check suite or run has been cancelled. */ + Cancelled = "CANCELLED", + /** The check suite or run has failed. */ + Failure = "FAILURE", + /** The check suite or run was neutral. */ + Neutral = "NEUTRAL", + /** The check suite or run was skipped. */ + Skipped = "SKIPPED", + /** The check suite or run was marked stale by GitHub. Only GitHub can use this conclusion. */ + Stale = "STALE", + /** The check suite or run has failed at startup. */ + StartupFailure = "STARTUP_FAILURE", + /** The check suite or run has succeeded. */ + Success = "SUCCESS", + /** The check suite or run has timed out. */ + TimedOut = "TIMED_OUT" +} +/** A check run. */ +export type CheckRun = Node & RequirableByPullRequest & UniformResourceLocatable & { + __typename?: 'CheckRun'; + /** The check run's annotations */ + annotations?: Maybe; + /** The check suite that this run is a part of. */ + checkSuite: CheckSuite; + /** Identifies the date and time when the check run was completed. */ + completedAt?: Maybe; + /** The conclusion of the check run. */ + conclusion?: Maybe; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The corresponding deployment for this job, if any */ + deployment?: Maybe; + /** The URL from which to find full details of the check run on the integrator's site. */ + detailsUrl?: Maybe; + /** A reference for the check run on the integrator's system. */ + externalId?: Maybe; + /** The Node ID of the CheckRun object */ + id: Scalars['ID']['output']; + /** Whether this is required to pass before merging for a specific pull request. */ + isRequired: Scalars['Boolean']['output']; + /** The name of the check for this check run. */ + name: Scalars['String']['output']; + /** Information about a pending deployment, if any, in this check run */ + pendingDeploymentRequest?: Maybe; + /** The permalink to the check run summary. */ + permalink: Scalars['URI']['output']; + /** The repository associated with this check run. */ + repository: Repository; + /** The HTTP path for this check run. */ + resourcePath: Scalars['URI']['output']; + /** Identifies the date and time when the check run was started. */ + startedAt?: Maybe; + /** The current status of the check run. */ + status: CheckStatusState; + /** The check run's steps */ + steps?: Maybe; + /** A string representing the check run's summary */ + summary?: Maybe; + /** A string representing the check run's text */ + text?: Maybe; + /** A string representing the check run */ + title?: Maybe; + /** The HTTP URL for this check run. */ + url: Scalars['URI']['output']; +}; +/** A check run. */ +export type CheckRunAnnotationsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A check run. */ +export type CheckRunIsRequiredArgs = { + pullRequestId?: InputMaybe; + pullRequestNumber?: InputMaybe; +}; +/** A check run. */ +export type CheckRunStepsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + number?: InputMaybe; +}; +/** Possible further actions the integrator can perform. */ +export type CheckRunAction = { + /** A short explanation of what this action would do. */ + description: Scalars['String']['input']; + /** A reference for the action on the integrator's system. */ + identifier: Scalars['String']['input']; + /** The text to be displayed on a button in the web UI. */ + label: Scalars['String']['input']; +}; +/** The connection type for CheckRun. */ +export type CheckRunConnection = { + __typename?: 'CheckRunConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type CheckRunEdge = { + __typename?: 'CheckRunEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** The filters that are available when fetching check runs. */ +export type CheckRunFilter = { + /** Filters the check runs created by this application ID. */ + appId?: InputMaybe; + /** Filters the check runs by this name. */ + checkName?: InputMaybe; + /** Filters the check runs by this type. */ + checkType?: InputMaybe; + /** Filters the check runs by these conclusions. */ + conclusions?: InputMaybe>; + /** Filters the check runs by this status. Superceded by statuses. */ + status?: InputMaybe; + /** Filters the check runs by this status. Overrides status. */ + statuses?: InputMaybe>; +}; +/** Descriptive details about the check run. */ +export type CheckRunOutput = { + /** The annotations that are made as part of the check run. */ + annotations?: InputMaybe>; + /** Images attached to the check run output displayed in the GitHub pull request UI. */ + images?: InputMaybe>; + /** The summary of the check run (supports Commonmark). */ + summary: Scalars['String']['input']; + /** The details of the check run (supports Commonmark). */ + text?: InputMaybe; + /** A title to provide for this check run. */ + title: Scalars['String']['input']; +}; +/** Images attached to the check run output displayed in the GitHub pull request UI. */ +export type CheckRunOutputImage = { + /** The alternative text for the image. */ + alt: Scalars['String']['input']; + /** A short image description. */ + caption?: InputMaybe; + /** The full URL of the image. */ + imageUrl: Scalars['URI']['input']; +}; +/** The possible states of a check run in a status rollup. */ +export declare enum CheckRunState { + /** The check run requires action. */ + ActionRequired = "ACTION_REQUIRED", + /** The check run has been cancelled. */ + Cancelled = "CANCELLED", + /** The check run has been completed. */ + Completed = "COMPLETED", + /** The check run has failed. */ + Failure = "FAILURE", + /** The check run is in progress. */ + InProgress = "IN_PROGRESS", + /** The check run was neutral. */ + Neutral = "NEUTRAL", + /** The check run is in pending state. */ + Pending = "PENDING", + /** The check run has been queued. */ + Queued = "QUEUED", + /** The check run was skipped. */ + Skipped = "SKIPPED", + /** The check run was marked stale by GitHub. Only GitHub can use this conclusion. */ + Stale = "STALE", + /** The check run has failed at startup. */ + StartupFailure = "STARTUP_FAILURE", + /** The check run has succeeded. */ + Success = "SUCCESS", + /** The check run has timed out. */ + TimedOut = "TIMED_OUT", + /** The check run is in waiting state. */ + Waiting = "WAITING" +} +/** Represents a count of the state of a check run. */ +export type CheckRunStateCount = { + __typename?: 'CheckRunStateCount'; + /** The number of check runs with this state. */ + count: Scalars['Int']['output']; + /** The state of a check run. */ + state: CheckRunState; +}; +/** The possible types of check runs. */ +export declare enum CheckRunType { + /** Every check run available. */ + All = "ALL", + /** The latest check run. */ + Latest = "LATEST" +} +/** The possible states for a check suite or run status. */ +export declare enum CheckStatusState { + /** The check suite or run has been completed. */ + Completed = "COMPLETED", + /** The check suite or run is in progress. */ + InProgress = "IN_PROGRESS", + /** The check suite or run is in pending state. */ + Pending = "PENDING", + /** The check suite or run has been queued. */ + Queued = "QUEUED", + /** The check suite or run has been requested. */ + Requested = "REQUESTED", + /** The check suite or run is in waiting state. */ + Waiting = "WAITING" +} +/** A single check step. */ +export type CheckStep = { + __typename?: 'CheckStep'; + /** Identifies the date and time when the check step was completed. */ + completedAt?: Maybe; + /** The conclusion of the check step. */ + conclusion?: Maybe; + /** A reference for the check step on the integrator's system. */ + externalId?: Maybe; + /** The step's name. */ + name: Scalars['String']['output']; + /** The index of the step in the list of steps of the parent check run. */ + number: Scalars['Int']['output']; + /** Number of seconds to completion. */ + secondsToCompletion?: Maybe; + /** Identifies the date and time when the check step was started. */ + startedAt?: Maybe; + /** The current status of the check step. */ + status: CheckStatusState; +}; +/** The connection type for CheckStep. */ +export type CheckStepConnection = { + __typename?: 'CheckStepConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type CheckStepEdge = { + __typename?: 'CheckStepEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** A check suite. */ +export type CheckSuite = Node & { + __typename?: 'CheckSuite'; + /** The GitHub App which created this check suite. */ + app?: Maybe; + /** The name of the branch for this check suite. */ + branch?: Maybe; + /** The check runs associated with a check suite. */ + checkRuns?: Maybe; + /** The commit for this check suite */ + commit: Commit; + /** The conclusion of this check suite. */ + conclusion?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The user who triggered the check suite. */ + creator?: Maybe; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The Node ID of the CheckSuite object */ + id: Scalars['ID']['output']; + /** A list of open pull requests matching the check suite. */ + matchingPullRequests?: Maybe; + /** The push that triggered this check suite. */ + push?: Maybe; + /** The repository associated with this check suite. */ + repository: Repository; + /** The HTTP path for this check suite */ + resourcePath: Scalars['URI']['output']; + /** The status of this check suite. */ + status: CheckStatusState; + /** Identifies the date and time when the object was last updated. */ + updatedAt: Scalars['DateTime']['output']; + /** The HTTP URL for this check suite */ + url: Scalars['URI']['output']; + /** The workflow run associated with this check suite. */ + workflowRun?: Maybe; +}; +/** A check suite. */ +export type CheckSuiteCheckRunsArgs = { + after?: InputMaybe; + before?: InputMaybe; + filterBy?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A check suite. */ +export type CheckSuiteMatchingPullRequestsArgs = { + after?: InputMaybe; + baseRefName?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + headRefName?: InputMaybe; + labels?: InputMaybe>; + last?: InputMaybe; + orderBy?: InputMaybe; + states?: InputMaybe>; +}; +/** The auto-trigger preferences that are available for check suites. */ +export type CheckSuiteAutoTriggerPreference = { + /** The node ID of the application that owns the check suite. */ + appId: Scalars['ID']['input']; + /** Set to `true` to enable automatic creation of CheckSuite events upon pushes to the repository. */ + setting: Scalars['Boolean']['input']; +}; +/** The connection type for CheckSuite. */ +export type CheckSuiteConnection = { + __typename?: 'CheckSuiteConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type CheckSuiteEdge = { + __typename?: 'CheckSuiteEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** The filters that are available when fetching check suites. */ +export type CheckSuiteFilter = { + /** Filters the check suites created by this application ID. */ + appId?: InputMaybe; + /** Filters the check suites by this name. */ + checkName?: InputMaybe; +}; +/** An object which can have its data claimed or claim data from another. */ +export type Claimable = Mannequin | User; +/** Autogenerated input type of ClearLabelsFromLabelable */ +export type ClearLabelsFromLabelableInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The id of the labelable object to clear the labels from. */ + labelableId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ClearLabelsFromLabelable. */ +export type ClearLabelsFromLabelablePayload = { + __typename?: 'ClearLabelsFromLabelablePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The item that was unlabeled. */ + labelable?: Maybe; +}; +/** Autogenerated input type of ClearProjectV2ItemFieldValue */ +export type ClearProjectV2ItemFieldValueInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the field to be cleared. */ + fieldId: Scalars['ID']['input']; + /** The ID of the item to be cleared. */ + itemId: Scalars['ID']['input']; + /** The ID of the Project. */ + projectId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ClearProjectV2ItemFieldValue. */ +export type ClearProjectV2ItemFieldValuePayload = { + __typename?: 'ClearProjectV2ItemFieldValuePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The updated item. */ + projectV2Item?: Maybe; +}; +/** Autogenerated input type of CloneProject */ +export type CloneProjectInput = { + /** The description of the project. */ + body?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** Whether or not to clone the source project's workflows. */ + includeWorkflows: Scalars['Boolean']['input']; + /** The name of the project. */ + name: Scalars['String']['input']; + /** The visibility of the project, defaults to false (private). */ + public?: InputMaybe; + /** The source project to clone. */ + sourceId: Scalars['ID']['input']; + /** The owner ID to create the project under. */ + targetOwnerId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CloneProject. */ +export type CloneProjectPayload = { + __typename?: 'CloneProjectPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The id of the JobStatus for populating cloned fields. */ + jobStatusId?: Maybe; + /** The new cloned project. */ + project?: Maybe; +}; +/** Autogenerated input type of CloneTemplateRepository */ +export type CloneTemplateRepositoryInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** A short description of the new repository. */ + description?: InputMaybe; + /** + * Whether to copy all branches from the template to the new repository. Defaults + * to copying only the default branch of the template. + */ + includeAllBranches?: InputMaybe; + /** The name of the new repository. */ + name: Scalars['String']['input']; + /** The ID of the owner for the new repository. */ + ownerId: Scalars['ID']['input']; + /** The Node ID of the template repository. */ + repositoryId: Scalars['ID']['input']; + /** Indicates the repository's visibility level. */ + visibility: RepositoryVisibility; +}; +/** Autogenerated return type of CloneTemplateRepository. */ +export type CloneTemplateRepositoryPayload = { + __typename?: 'CloneTemplateRepositoryPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The new repository. */ + repository?: Maybe; +}; +/** An object that can be closed */ +export type Closable = { + /** Indicates if the object is closed (definition of closed may depend on type) */ + closed: Scalars['Boolean']['output']; + /** Identifies the date and time when the object was closed. */ + closedAt?: Maybe; + /** Indicates if the object can be closed by the viewer. */ + viewerCanClose: Scalars['Boolean']['output']; + /** Indicates if the object can be reopened by the viewer. */ + viewerCanReopen: Scalars['Boolean']['output']; +}; +/** Autogenerated input type of CloseDiscussion */ +export type CloseDiscussionInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** ID of the discussion to be closed. */ + discussionId: Scalars['ID']['input']; + /** The reason why the discussion is being closed. */ + reason?: InputMaybe; +}; +/** Autogenerated return type of CloseDiscussion. */ +export type CloseDiscussionPayload = { + __typename?: 'CloseDiscussionPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The discussion that was closed. */ + discussion?: Maybe; +}; +/** Autogenerated input type of CloseIssue */ +export type CloseIssueInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** ID of the issue to be closed. */ + issueId: Scalars['ID']['input']; + /** The reason the issue is to be closed. */ + stateReason?: InputMaybe; +}; +/** Autogenerated return type of CloseIssue. */ +export type CloseIssuePayload = { + __typename?: 'CloseIssuePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The issue that was closed. */ + issue?: Maybe; +}; +/** Autogenerated input type of ClosePullRequest */ +export type ClosePullRequestInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** ID of the pull request to be closed. */ + pullRequestId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ClosePullRequest. */ +export type ClosePullRequestPayload = { + __typename?: 'ClosePullRequestPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The pull request that was closed. */ + pullRequest?: Maybe; +}; +/** Represents a 'closed' event on any `Closable`. */ +export type ClosedEvent = Node & UniformResourceLocatable & { + __typename?: 'ClosedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Object that was closed. */ + closable: Closable; + /** Object which triggered the creation of this event. */ + closer?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the ClosedEvent object */ + id: Scalars['ID']['output']; + /** The HTTP path for this closed event. */ + resourcePath: Scalars['URI']['output']; + /** The reason the issue state was changed to closed. */ + stateReason?: Maybe; + /** The HTTP URL for this closed event. */ + url: Scalars['URI']['output']; +}; +/** The object which triggered a `ClosedEvent`. */ +export type Closer = Commit | ProjectV2 | PullRequest; +/** The Code of Conduct for a repository */ +export type CodeOfConduct = Node & { + __typename?: 'CodeOfConduct'; + /** The body of the Code of Conduct */ + body?: Maybe; + /** The Node ID of the CodeOfConduct object */ + id: Scalars['ID']['output']; + /** The key for the Code of Conduct */ + key: Scalars['String']['output']; + /** The formal name of the Code of Conduct */ + name: Scalars['String']['output']; + /** The HTTP path for this Code of Conduct */ + resourcePath?: Maybe; + /** The HTTP URL for this Code of Conduct */ + url?: Maybe; +}; +/** + * Choose which tools must provide code scanning results before the reference is + * updated. When configured, code scanning must be enabled and have results for + * both the commit and the reference being updated. + */ +export type CodeScanningParameters = { + __typename?: 'CodeScanningParameters'; + /** Tools that must provide code scanning results for this rule to pass. */ + codeScanningTools: Array; +}; +/** + * Choose which tools must provide code scanning results before the reference is + * updated. When configured, code scanning must be enabled and have results for + * both the commit and the reference being updated. + */ +export type CodeScanningParametersInput = { + /** Tools that must provide code scanning results for this rule to pass. */ + codeScanningTools: Array; +}; +/** A tool that must provide code scanning results for this rule to pass. */ +export type CodeScanningTool = { + __typename?: 'CodeScanningTool'; + /** + * The severity level at which code scanning results that raise alerts block a + * reference update. For more information on alert severity levels, see "[About code scanning alerts](${externalDocsUrl}/code-security/code-scanning/managing-code-scanning-alerts/about-code-scanning-alerts#about-alert-severity-and-security-severity-levels)." + */ + alertsThreshold: Scalars['String']['output']; + /** + * The severity level at which code scanning results that raise security alerts + * block a reference update. For more information on security severity levels, + * see "[About code scanning alerts](${externalDocsUrl}/code-security/code-scanning/managing-code-scanning-alerts/about-code-scanning-alerts#about-alert-severity-and-security-severity-levels)." + */ + securityAlertsThreshold: Scalars['String']['output']; + /** The name of a code scanning tool */ + tool: Scalars['String']['output']; +}; +/** A tool that must provide code scanning results for this rule to pass. */ +export type CodeScanningToolInput = { + /** + * The severity level at which code scanning results that raise alerts block a + * reference update. For more information on alert severity levels, see "[About code scanning alerts](${externalDocsUrl}/code-security/code-scanning/managing-code-scanning-alerts/about-code-scanning-alerts#about-alert-severity-and-security-severity-levels)." + */ + alertsThreshold: Scalars['String']['input']; + /** + * The severity level at which code scanning results that raise security alerts + * block a reference update. For more information on security severity levels, + * see "[About code scanning alerts](${externalDocsUrl}/code-security/code-scanning/managing-code-scanning-alerts/about-code-scanning-alerts#about-alert-severity-and-security-severity-levels)." + */ + securityAlertsThreshold: Scalars['String']['input']; + /** The name of a code scanning tool */ + tool: Scalars['String']['input']; +}; +/** Collaborators affiliation level with a subject. */ +export declare enum CollaboratorAffiliation { + /** All collaborators the authenticated user can see. */ + All = "ALL", + /** All collaborators with permissions to an organization-owned subject, regardless of organization membership status. */ + Direct = "DIRECT", + /** All outside collaborators of an organization-owned subject. */ + Outside = "OUTSIDE" +} +/** Represents a comment. */ +export type Comment = { + /** The actor who authored the comment. */ + author?: Maybe; + /** Author's association with the subject of the comment. */ + authorAssociation: CommentAuthorAssociation; + /** The body as Markdown. */ + body: Scalars['String']['output']; + /** The body rendered to HTML. */ + bodyHTML: Scalars['HTML']['output']; + /** The body rendered to text. */ + bodyText: Scalars['String']['output']; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Check if this comment was created via an email reply. */ + createdViaEmail: Scalars['Boolean']['output']; + /** The actor who edited the comment. */ + editor?: Maybe; + /** The Node ID of the Comment object */ + id: Scalars['ID']['output']; + /** Check if this comment was edited and includes an edit with the creation data */ + includesCreatedEdit: Scalars['Boolean']['output']; + /** The moment the editor made the last edit */ + lastEditedAt?: Maybe; + /** Identifies when the comment was published at. */ + publishedAt?: Maybe; + /** Identifies the date and time when the object was last updated. */ + updatedAt: Scalars['DateTime']['output']; + /** A list of edits to this content. */ + userContentEdits?: Maybe; + /** Did the viewer author this comment. */ + viewerDidAuthor: Scalars['Boolean']['output']; +}; +/** Represents a comment. */ +export type CommentUserContentEditsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** A comment author association with repository. */ +export declare enum CommentAuthorAssociation { + /** Author has been invited to collaborate on the repository. */ + Collaborator = "COLLABORATOR", + /** Author has previously committed to the repository. */ + Contributor = "CONTRIBUTOR", + /** Author has not previously committed to GitHub. */ + FirstTimer = "FIRST_TIMER", + /** Author has not previously committed to the repository. */ + FirstTimeContributor = "FIRST_TIME_CONTRIBUTOR", + /** Author is a placeholder for an unclaimed user. */ + Mannequin = "MANNEQUIN", + /** Author is a member of the organization that owns the repository. */ + Member = "MEMBER", + /** Author has no association with the repository. */ + None = "NONE", + /** Author is the owner of the repository. */ + Owner = "OWNER" +} +/** The possible errors that will prevent a user from updating a comment. */ +export declare enum CommentCannotUpdateReason { + /** Unable to create comment because repository is archived. */ + Archived = "ARCHIVED", + /** You cannot update this comment */ + Denied = "DENIED", + /** You must be the author or have write access to this repository to update this comment. */ + InsufficientAccess = "INSUFFICIENT_ACCESS", + /** Unable to create comment because issue is locked. */ + Locked = "LOCKED", + /** You must be logged in to update this comment. */ + LoginRequired = "LOGIN_REQUIRED", + /** Repository is under maintenance. */ + Maintenance = "MAINTENANCE", + /** At least one email address must be verified to update this comment. */ + VerifiedEmailRequired = "VERIFIED_EMAIL_REQUIRED" +} +/** Represents a 'comment_deleted' event on a given issue or pull request. */ +export type CommentDeletedEvent = Node & { + __typename?: 'CommentDeletedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The user who authored the deleted comment. */ + deletedCommentAuthor?: Maybe; + /** The Node ID of the CommentDeletedEvent object */ + id: Scalars['ID']['output']; +}; +/** Represents a Git commit. */ +export type Commit = GitObject & Node & Subscribable & UniformResourceLocatable & { + __typename?: 'Commit'; + /** An abbreviated version of the Git object ID */ + abbreviatedOid: Scalars['String']['output']; + /** The number of additions in this commit. */ + additions: Scalars['Int']['output']; + /** + * 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 + */ + associatedPullRequests?: Maybe; + /** Authorship details of the commit. */ + author?: Maybe; + /** Check if the committer and the author match. */ + authoredByCommitter: Scalars['Boolean']['output']; + /** The datetime when this commit was authored. */ + authoredDate: Scalars['DateTime']['output']; + /** + * 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. + */ + authors: GitActorConnection; + /** Fetches `git blame` information. */ + blame: Blame; + /** + * We recommend using the `changedFilesIfAvailable` field instead of + * `changedFiles`, as `changedFiles` will cause your request to return an error + * if GitHub is unable to calculate the number of changed files. + * @deprecated `changedFiles` will be removed. Use `changedFilesIfAvailable` instead. Removal on 2023-01-01 UTC. + */ + changedFiles: Scalars['Int']['output']; + /** + * The number of changed files in this commit. If GitHub is unable to calculate + * the number of changed files (for example due to a timeout), this will return + * `null`. We recommend using this field instead of `changedFiles`. + */ + changedFilesIfAvailable?: Maybe; + /** The check suites associated with a commit. */ + checkSuites?: Maybe; + /** Comments made on the commit. */ + comments: CommitCommentConnection; + /** The HTTP path for this Git object */ + commitResourcePath: Scalars['URI']['output']; + /** The HTTP URL for this Git object */ + commitUrl: Scalars['URI']['output']; + /** The datetime when this commit was committed. */ + committedDate: Scalars['DateTime']['output']; + /** Check if committed via GitHub web UI. */ + committedViaWeb: Scalars['Boolean']['output']; + /** Committer details of the commit. */ + committer?: Maybe; + /** The number of deletions in this commit. */ + deletions: Scalars['Int']['output']; + /** The deployments associated with a commit. */ + deployments?: Maybe; + /** The tree entry representing the file located at the given path. */ + file?: Maybe; + /** The linear commit history starting from (and including) this commit, in the same order as `git log`. */ + history: CommitHistoryConnection; + /** The Node ID of the Commit object */ + id: Scalars['ID']['output']; + /** The Git commit message */ + message: Scalars['String']['output']; + /** The Git commit message body */ + messageBody: Scalars['String']['output']; + /** The commit message body rendered to HTML. */ + messageBodyHTML: Scalars['HTML']['output']; + /** The Git commit message headline */ + messageHeadline: Scalars['String']['output']; + /** The commit message headline rendered to HTML. */ + messageHeadlineHTML: Scalars['HTML']['output']; + /** The Git object ID */ + oid: Scalars['GitObjectID']['output']; + /** The organization this commit was made on behalf of. */ + onBehalfOf?: Maybe; + /** The parents of a commit. */ + parents: CommitConnection; + /** + * The datetime when this commit was pushed. + * @deprecated `pushedDate` is no longer supported. Removal on 2023-07-01 UTC. + */ + pushedDate?: Maybe; + /** The Repository this commit belongs to */ + repository: Repository; + /** The HTTP path for this commit */ + resourcePath: Scalars['URI']['output']; + /** Commit signing information, if present. */ + signature?: Maybe; + /** Status information for this commit */ + status?: Maybe; + /** Check and Status rollup information for this commit. */ + statusCheckRollup?: Maybe; + /** Returns a list of all submodules in this repository as of this Commit parsed from the .gitmodules file. */ + submodules: SubmoduleConnection; + /** + * Returns a URL to download a tarball archive for a repository. + * Note: For private repositories, these links are temporary and expire after five minutes. + */ + tarballUrl: Scalars['URI']['output']; + /** Commit's root Tree */ + tree: Tree; + /** The HTTP path for the tree of this commit */ + treeResourcePath: Scalars['URI']['output']; + /** The HTTP URL for the tree of this commit */ + treeUrl: Scalars['URI']['output']; + /** The HTTP URL for this commit */ + url: Scalars['URI']['output']; + /** Check if the viewer is able to change their subscription status for the repository. */ + viewerCanSubscribe: Scalars['Boolean']['output']; + /** Identifies if the viewer is watching, not watching, or ignoring the subscribable entity. */ + viewerSubscription?: Maybe; + /** + * Returns a URL to download a zipball archive for a repository. + * Note: For private repositories, these links are temporary and expire after five minutes. + */ + zipballUrl: Scalars['URI']['output']; +}; +/** Represents a Git commit. */ +export type CommitAssociatedPullRequestsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** Represents a Git commit. */ +export type CommitAuthorsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** Represents a Git commit. */ +export type CommitBlameArgs = { + path: Scalars['String']['input']; +}; +/** Represents a Git commit. */ +export type CommitCheckSuitesArgs = { + after?: InputMaybe; + before?: InputMaybe; + filterBy?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** Represents a Git commit. */ +export type CommitCommentsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** Represents a Git commit. */ +export type CommitDeploymentsArgs = { + after?: InputMaybe; + before?: InputMaybe; + environments?: InputMaybe>; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** Represents a Git commit. */ +export type CommitFileArgs = { + path: Scalars['String']['input']; +}; +/** Represents a Git commit. */ +export type CommitHistoryArgs = { + after?: InputMaybe; + author?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + path?: InputMaybe; + since?: InputMaybe; + until?: InputMaybe; +}; +/** Represents a Git commit. */ +export type CommitParentsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** Represents a Git commit. */ +export type CommitSubmodulesArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** Specifies an author for filtering Git commits. */ +export type CommitAuthor = { + /** Email addresses to filter by. Commits authored by any of the specified email addresses will be returned. */ + emails?: InputMaybe>; + /** + * 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. + */ + id?: InputMaybe; +}; +/** Parameters to be used for the commit_author_email_pattern rule */ +export type CommitAuthorEmailPatternParameters = { + __typename?: 'CommitAuthorEmailPatternParameters'; + /** How this rule will appear to users. */ + name?: Maybe; + /** If true, the rule will fail if the pattern matches. */ + negate: Scalars['Boolean']['output']; + /** The operator to use for matching. */ + operator: Scalars['String']['output']; + /** The pattern to match with. */ + pattern: Scalars['String']['output']; +}; +/** Parameters to be used for the commit_author_email_pattern rule */ +export type CommitAuthorEmailPatternParametersInput = { + /** How this rule will appear to users. */ + name?: InputMaybe; + /** If true, the rule will fail if the pattern matches. */ + negate?: InputMaybe; + /** The operator to use for matching. */ + operator: Scalars['String']['input']; + /** The pattern to match with. */ + pattern: Scalars['String']['input']; +}; +/** Represents a comment on a given Commit. */ +export type CommitComment = Comment & Deletable & Minimizable & Node & Reactable & RepositoryNode & Updatable & UpdatableComment & { + __typename?: 'CommitComment'; + /** The actor who authored the comment. */ + author?: Maybe; + /** Author's association with the subject of the comment. */ + authorAssociation: CommentAuthorAssociation; + /** Identifies the comment body. */ + body: Scalars['String']['output']; + /** The body rendered to HTML. */ + bodyHTML: Scalars['HTML']['output']; + /** The body rendered to text. */ + bodyText: Scalars['String']['output']; + /** Identifies the commit associated with the comment, if the commit exists. */ + commit?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Check if this comment was created via an email reply. */ + createdViaEmail: Scalars['Boolean']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The actor who edited the comment. */ + editor?: Maybe; + /** The Node ID of the CommitComment object */ + id: Scalars['ID']['output']; + /** Check if this comment was edited and includes an edit with the creation data */ + includesCreatedEdit: Scalars['Boolean']['output']; + /** Returns whether or not a comment has been minimized. */ + isMinimized: Scalars['Boolean']['output']; + /** The moment the editor made the last edit */ + lastEditedAt?: Maybe; + /** + * Returns why the comment was minimized. One of `abuse`, `off-topic`, + * `outdated`, `resolved`, `duplicate` and `spam`. Note that the case and + * formatting of these values differs from the inputs to the `MinimizeComment` mutation. + */ + minimizedReason?: Maybe; + /** Identifies the file path associated with the comment. */ + path?: Maybe; + /** Identifies the line position associated with the comment. */ + position?: Maybe; + /** Identifies when the comment was published at. */ + publishedAt?: Maybe; + /** A list of reactions grouped by content left on the subject. */ + reactionGroups?: Maybe>; + /** A list of Reactions left on the Issue. */ + reactions: ReactionConnection; + /** The repository associated with this node. */ + repository: Repository; + /** The HTTP path permalink for this commit comment. */ + resourcePath: Scalars['URI']['output']; + /** Identifies the date and time when the object was last updated. */ + updatedAt: Scalars['DateTime']['output']; + /** The HTTP URL permalink for this commit comment. */ + url: Scalars['URI']['output']; + /** A list of edits to this content. */ + userContentEdits?: Maybe; + /** Check if the current viewer can delete this object. */ + viewerCanDelete: Scalars['Boolean']['output']; + /** Check if the current viewer can minimize this object. */ + viewerCanMinimize: Scalars['Boolean']['output']; + /** Can user react to this subject */ + viewerCanReact: Scalars['Boolean']['output']; + /** Check if the current viewer can update this object. */ + viewerCanUpdate: Scalars['Boolean']['output']; + /** Reasons why the current viewer can not update this comment. */ + viewerCannotUpdateReasons: Array; + /** Did the viewer author this comment. */ + viewerDidAuthor: Scalars['Boolean']['output']; +}; +/** Represents a comment on a given Commit. */ +export type CommitCommentReactionsArgs = { + after?: InputMaybe; + before?: InputMaybe; + content?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** Represents a comment on a given Commit. */ +export type CommitCommentUserContentEditsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** The connection type for CommitComment. */ +export type CommitCommentConnection = { + __typename?: 'CommitCommentConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** An edge in a connection. */ +export type CommitCommentEdge = { + __typename?: 'CommitCommentEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** A thread of comments on a commit. */ +export type CommitCommentThread = Node & RepositoryNode & { + __typename?: 'CommitCommentThread'; + /** The comments that exist in this thread. */ + comments: CommitCommentConnection; + /** The commit the comments were made on. */ + commit?: Maybe; + /** The Node ID of the CommitCommentThread object */ + id: Scalars['ID']['output']; + /** The file the comments were made on. */ + path?: Maybe; + /** The position in the diff for the commit that the comment was made on. */ + position?: Maybe; + /** The repository associated with this node. */ + repository: Repository; +}; +/** A thread of comments on a commit. */ +export type CommitCommentThreadCommentsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** The connection type for Commit. */ +export type CommitConnection = { + __typename?: 'CommitConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** Ordering options for commit contribution connections. */ +export type CommitContributionOrder = { + /** The ordering direction. */ + direction: OrderDirection; + /** The field by which to order commit contributions. */ + field: CommitContributionOrderField; +}; +/** Properties by which commit contribution connections can be ordered. */ +export declare enum CommitContributionOrderField { + /** Order commit contributions by how many commits they represent. */ + CommitCount = "COMMIT_COUNT", + /** Order commit contributions by when they were made. */ + OccurredAt = "OCCURRED_AT" +} +/** This aggregates commits made by a user within one repository. */ +export type CommitContributionsByRepository = { + __typename?: 'CommitContributionsByRepository'; + /** The commit contributions, each representing a day. */ + contributions: CreatedCommitContributionConnection; + /** The repository in which the commits were made. */ + repository: Repository; + /** The HTTP path for the user's commits to the repository in this time range. */ + resourcePath: Scalars['URI']['output']; + /** The HTTP URL for the user's commits to the repository in this time range. */ + url: Scalars['URI']['output']; +}; +/** This aggregates commits made by a user within one repository. */ +export type CommitContributionsByRepositoryContributionsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** An edge in a connection. */ +export type CommitEdge = { + __typename?: 'CommitEdge'; + /** A cursor for use in pagination. */ + cursor: Scalars['String']['output']; + /** The item at the end of the edge. */ + node?: Maybe; +}; +/** The connection type for Commit. */ +export type CommitHistoryConnection = { + __typename?: 'CommitHistoryConnection'; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** A message to include with a new commit */ +export type CommitMessage = { + /** The body of the message. */ + body?: InputMaybe; + /** The headline of the message. */ + headline: Scalars['String']['input']; +}; +/** Parameters to be used for the commit_message_pattern rule */ +export type CommitMessagePatternParameters = { + __typename?: 'CommitMessagePatternParameters'; + /** How this rule will appear to users. */ + name?: Maybe; + /** If true, the rule will fail if the pattern matches. */ + negate: Scalars['Boolean']['output']; + /** The operator to use for matching. */ + operator: Scalars['String']['output']; + /** The pattern to match with. */ + pattern: Scalars['String']['output']; +}; +/** Parameters to be used for the commit_message_pattern rule */ +export type CommitMessagePatternParametersInput = { + /** How this rule will appear to users. */ + name?: InputMaybe; + /** If true, the rule will fail if the pattern matches. */ + negate?: InputMaybe; + /** The operator to use for matching. */ + operator: Scalars['String']['input']; + /** The pattern to match with. */ + pattern: Scalars['String']['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 + * `repositoryNameWithOwner` and `branchName`. + * + * ### Examples + * + * Specify a branch using a global node ID: + * + * { "id": "MDM6UmVmMTpyZWZzL2hlYWRzL21haW4=" } + * + * Specify a branch using `repositoryNameWithOwner` and `branchName`: + * + * { + * "repositoryNameWithOwner": "github/graphql-client", + * "branchName": "main" + * } + */ +export type CommittableBranch = { + /** The unqualified name of the branch to append the commit to. */ + branchName?: InputMaybe; + /** The Node ID of the Ref to be updated. */ + id?: InputMaybe; + /** The nameWithOwner of the repository to commit to. */ + repositoryNameWithOwner?: InputMaybe; +}; +/** Parameters to be used for the committer_email_pattern rule */ +export type CommitterEmailPatternParameters = { + __typename?: 'CommitterEmailPatternParameters'; + /** How this rule will appear to users. */ + name?: Maybe; + /** If true, the rule will fail if the pattern matches. */ + negate: Scalars['Boolean']['output']; + /** The operator to use for matching. */ + operator: Scalars['String']['output']; + /** The pattern to match with. */ + pattern: Scalars['String']['output']; +}; +/** Parameters to be used for the committer_email_pattern rule */ +export type CommitterEmailPatternParametersInput = { + /** How this rule will appear to users. */ + name?: InputMaybe; + /** If true, the rule will fail if the pattern matches. */ + negate?: InputMaybe; + /** The operator to use for matching. */ + operator: Scalars['String']['input']; + /** The pattern to match with. */ + pattern: Scalars['String']['input']; +}; +/** Represents a comparison between two commit revisions. */ +export type Comparison = Node & { + __typename?: 'Comparison'; + /** The number of commits ahead of the base branch. */ + aheadBy: Scalars['Int']['output']; + /** The base revision of this comparison. */ + baseTarget: GitObject; + /** The number of commits behind the base branch. */ + behindBy: Scalars['Int']['output']; + /** The commits which compose this comparison. */ + commits: ComparisonCommitConnection; + /** The head revision of this comparison. */ + headTarget: GitObject; + /** The Node ID of the Comparison object */ + id: Scalars['ID']['output']; + /** The status of this comparison. */ + status: ComparisonStatus; +}; +/** Represents a comparison between two commit revisions. */ +export type ComparisonCommitsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; +}; +/** The connection type for Commit. */ +export type ComparisonCommitConnection = { + __typename?: 'ComparisonCommitConnection'; + /** The total count of authors and co-authors across all commits. */ + authorCount: Scalars['Int']['output']; + /** A list of edges. */ + edges?: Maybe>>; + /** A list of nodes. */ + nodes?: Maybe>>; + /** Information to aid in pagination. */ + pageInfo: PageInfo; + /** Identifies the total count of items in the connection. */ + totalCount: Scalars['Int']['output']; +}; +/** The status of a git comparison between two refs. */ +export declare enum ComparisonStatus { + /** The head ref is ahead of the base ref. */ + Ahead = "AHEAD", + /** The head ref is behind the base ref. */ + Behind = "BEHIND", + /** The head ref is both ahead and behind of the base ref, indicating git history has diverged. */ + Diverged = "DIVERGED", + /** The head ref and base ref are identical. */ + Identical = "IDENTICAL" +} +/** Represents a 'connected' event on a given issue or pull request. */ +export type ConnectedEvent = Node & { + __typename?: 'ConnectedEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the ConnectedEvent object */ + id: Scalars['ID']['output']; + /** Reference originated in a different repository. */ + isCrossRepository: Scalars['Boolean']['output']; + /** Issue or pull request that made the reference. */ + source: ReferencedSubject; + /** Issue or pull request which was connected. */ + subject: ReferencedSubject; +}; +/** The Contributing Guidelines for a repository. */ +export type ContributingGuidelines = { + __typename?: 'ContributingGuidelines'; + /** The body of the Contributing Guidelines. */ + body?: Maybe; + /** The HTTP path for the Contributing Guidelines. */ + resourcePath?: Maybe; + /** The HTTP URL for the Contributing Guidelines. */ + url?: Maybe; +}; +/** Represents a contribution a user made on GitHub, such as opening an issue. */ +export type Contribution = { + /** + * 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. + */ + isRestricted: Scalars['Boolean']['output']; + /** When this contribution was made. */ + occurredAt: Scalars['DateTime']['output']; + /** The HTTP path for this contribution. */ + resourcePath: Scalars['URI']['output']; + /** The HTTP URL for this contribution. */ + url: Scalars['URI']['output']; + /** The user who made this contribution. */ + user: User; +}; +/** A calendar of contributions made on GitHub by a user. */ +export type ContributionCalendar = { + __typename?: 'ContributionCalendar'; + /** A list of hex color codes used in this calendar. The darker the color, the more contributions it represents. */ + colors: Array; + /** Determine if the color set was chosen because it's currently Halloween. */ + isHalloween: Scalars['Boolean']['output']; + /** A list of the months of contributions in this calendar. */ + months: Array; + /** The count of total contributions in the calendar. */ + totalContributions: Scalars['Int']['output']; + /** A list of the weeks of contributions in this calendar. */ + weeks: Array; +}; +/** Represents a single day of contributions on GitHub by a user. */ +export type ContributionCalendarDay = { + __typename?: 'ContributionCalendarDay'; + /** The hex color code that represents how many contributions were made on this day compared to others in the calendar. */ + color: Scalars['String']['output']; + /** How many contributions were made by the user on this day. */ + contributionCount: Scalars['Int']['output']; + /** + * Indication of contributions, relative to other days. Can be used to indicate + * which color to represent this day on a calendar. + */ + contributionLevel: ContributionLevel; + /** The day this square represents. */ + date: Scalars['Date']['output']; + /** A number representing which day of the week this square represents, e.g., 1 is Monday. */ + weekday: Scalars['Int']['output']; +}; +/** A month of contributions in a user's contribution graph. */ +export type ContributionCalendarMonth = { + __typename?: 'ContributionCalendarMonth'; + /** The date of the first day of this month. */ + firstDay: Scalars['Date']['output']; + /** The name of the month. */ + name: Scalars['String']['output']; + /** How many weeks started in this month. */ + totalWeeks: Scalars['Int']['output']; + /** The year the month occurred in. */ + year: Scalars['Int']['output']; +}; +/** A week of contributions in a user's contribution graph. */ +export type ContributionCalendarWeek = { + __typename?: 'ContributionCalendarWeek'; + /** The days of contributions in this week. */ + contributionDays: Array; + /** The date of the earliest square in this week. */ + firstDay: Scalars['Date']['output']; +}; +/** Varying levels of contributions from none to many. */ +export declare enum ContributionLevel { + /** Lowest 25% of days of contributions. */ + FirstQuartile = "FIRST_QUARTILE", + /** Highest 25% of days of contributions. More contributions than the third quartile. */ + FourthQuartile = "FOURTH_QUARTILE", + /** No contributions occurred. */ + None = "NONE", + /** Second lowest 25% of days of contributions. More contributions than the first quartile. */ + SecondQuartile = "SECOND_QUARTILE", + /** Second highest 25% of days of contributions. More contributions than second quartile, less than the fourth quartile. */ + ThirdQuartile = "THIRD_QUARTILE" +} +/** Ordering options for contribution connections. */ +export type ContributionOrder = { + /** The ordering direction. */ + direction: OrderDirection; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollection = { + __typename?: 'ContributionsCollection'; + /** Commit contributions made by the user, grouped by repository. */ + commitContributionsByRepository: Array; + /** A calendar of this user's contributions on GitHub. */ + contributionCalendar: ContributionCalendar; + /** The years the user has been making contributions with the most recent year first. */ + contributionYears: Array; + /** Determine if this collection's time span ends in the current month. */ + doesEndInCurrentMonth: Scalars['Boolean']['output']; + /** + * 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. + */ + earliestRestrictedContributionDate?: Maybe; + /** The ending date and time of this collection. */ + endedAt: Scalars['DateTime']['output']; + /** + * 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. + */ + firstIssueContribution?: Maybe; + /** + * 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. + */ + firstPullRequestContribution?: Maybe; + /** + * 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. + */ + firstRepositoryContribution?: Maybe; + /** Does the user have any more activity in the timeline that occurred prior to the collection's time range? */ + hasActivityInThePast: Scalars['Boolean']['output']; + /** Determine if there are any contributions in this collection. */ + hasAnyContributions: Scalars['Boolean']['output']; + /** + * 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. + */ + hasAnyRestrictedContributions: Scalars['Boolean']['output']; + /** Whether or not the collector's time span is all within the same day. */ + isSingleDay: Scalars['Boolean']['output']; + /** A list of issues the user opened. */ + issueContributions: CreatedIssueContributionConnection; + /** Issue contributions made by the user, grouped by repository. */ + issueContributionsByRepository: Array; + /** + * 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. + */ + joinedGitHubContribution?: Maybe; + /** + * 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. + */ + latestRestrictedContributionDate?: Maybe; + /** + * 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. + */ + mostRecentCollectionWithActivity?: Maybe; + /** + * Returns a different contributions collection from an earlier time range than this one + * that does not have any contributions. + */ + mostRecentCollectionWithoutActivity?: Maybe; + /** + * The issue the user opened on GitHub that received the most comments in the specified + * time frame. + */ + popularIssueContribution?: Maybe; + /** + * The pull request the user opened on GitHub that received the most comments in the + * specified time frame. + */ + popularPullRequestContribution?: Maybe; + /** Pull request contributions made by the user. */ + pullRequestContributions: CreatedPullRequestContributionConnection; + /** Pull request contributions made by the user, grouped by repository. */ + pullRequestContributionsByRepository: Array; + /** + * Pull request review contributions made by the user. Returns the most recently + * submitted review for each PR reviewed by the user. + */ + pullRequestReviewContributions: CreatedPullRequestReviewContributionConnection; + /** Pull request review contributions made by the user, grouped by repository. */ + pullRequestReviewContributionsByRepository: Array; + /** A list of repositories owned by the user that the user created in this time range. */ + repositoryContributions: CreatedRepositoryContributionConnection; + /** + * 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. + */ + restrictedContributionsCount: Scalars['Int']['output']; + /** The beginning date and time of this collection. */ + startedAt: Scalars['DateTime']['output']; + /** How many commits were made by the user in this time span. */ + totalCommitContributions: Scalars['Int']['output']; + /** How many issues the user opened. */ + totalIssueContributions: Scalars['Int']['output']; + /** How many pull requests the user opened. */ + totalPullRequestContributions: Scalars['Int']['output']; + /** How many pull request reviews the user left. */ + totalPullRequestReviewContributions: Scalars['Int']['output']; + /** How many different repositories the user committed to. */ + totalRepositoriesWithContributedCommits: Scalars['Int']['output']; + /** How many different repositories the user opened issues in. */ + totalRepositoriesWithContributedIssues: Scalars['Int']['output']; + /** How many different repositories the user left pull request reviews in. */ + totalRepositoriesWithContributedPullRequestReviews: Scalars['Int']['output']; + /** How many different repositories the user opened pull requests in. */ + totalRepositoriesWithContributedPullRequests: Scalars['Int']['output']; + /** How many repositories the user created. */ + totalRepositoryContributions: Scalars['Int']['output']; + /** The user who made the contributions in this collection. */ + user: User; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionCommitContributionsByRepositoryArgs = { + maxRepositories?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionIssueContributionsArgs = { + after?: InputMaybe; + before?: InputMaybe; + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionIssueContributionsByRepositoryArgs = { + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; + maxRepositories?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionPullRequestContributionsArgs = { + after?: InputMaybe; + before?: InputMaybe; + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionPullRequestContributionsByRepositoryArgs = { + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; + maxRepositories?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionPullRequestReviewContributionsArgs = { + after?: InputMaybe; + before?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionPullRequestReviewContributionsByRepositoryArgs = { + maxRepositories?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionRepositoryContributionsArgs = { + after?: InputMaybe; + before?: InputMaybe; + excludeFirst?: InputMaybe; + first?: InputMaybe; + last?: InputMaybe; + orderBy?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionTotalIssueContributionsArgs = { + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionTotalPullRequestContributionsArgs = { + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionTotalRepositoriesWithContributedIssuesArgs = { + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionTotalRepositoriesWithContributedPullRequestsArgs = { + excludeFirst?: InputMaybe; + excludePopular?: InputMaybe; +}; +/** A contributions collection aggregates contributions such as opened issues and commits created by a user. */ +export type ContributionsCollectionTotalRepositoryContributionsArgs = { + excludeFirst?: InputMaybe; +}; +/** Autogenerated input type of ConvertProjectCardNoteToIssue */ +export type ConvertProjectCardNoteToIssueInput = { + /** The body of the newly created issue. */ + body?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ProjectCard ID to convert. */ + projectCardId: Scalars['ID']['input']; + /** The ID of the repository to create the issue in. */ + repositoryId: Scalars['ID']['input']; + /** The title of the newly created issue. Defaults to the card's note text. */ + title?: InputMaybe; +}; +/** Autogenerated return type of ConvertProjectCardNoteToIssue. */ +export type ConvertProjectCardNoteToIssuePayload = { + __typename?: 'ConvertProjectCardNoteToIssuePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The updated ProjectCard. */ + projectCard?: Maybe; +}; +/** Autogenerated input type of ConvertProjectV2DraftIssueItemToIssue */ +export type ConvertProjectV2DraftIssueItemToIssueInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the draft issue ProjectV2Item to convert. */ + itemId: Scalars['ID']['input']; + /** The ID of the repository to create the issue in. */ + repositoryId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ConvertProjectV2DraftIssueItemToIssue. */ +export type ConvertProjectV2DraftIssueItemToIssuePayload = { + __typename?: 'ConvertProjectV2DraftIssueItemToIssuePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The updated project item. */ + item?: Maybe; +}; +/** Autogenerated input type of ConvertPullRequestToDraft */ +export type ConvertPullRequestToDraftInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** ID of the pull request to convert to draft */ + pullRequestId: Scalars['ID']['input']; +}; +/** Autogenerated return type of ConvertPullRequestToDraft. */ +export type ConvertPullRequestToDraftPayload = { + __typename?: 'ConvertPullRequestToDraftPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The pull request that is now a draft. */ + pullRequest?: Maybe; +}; +/** Represents a 'convert_to_draft' event on a given pull request. */ +export type ConvertToDraftEvent = Node & UniformResourceLocatable & { + __typename?: 'ConvertToDraftEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The Node ID of the ConvertToDraftEvent object */ + id: Scalars['ID']['output']; + /** PullRequest referenced by event. */ + pullRequest: PullRequest; + /** The HTTP path for this convert to draft event. */ + resourcePath: Scalars['URI']['output']; + /** The HTTP URL for this convert to draft event. */ + url: Scalars['URI']['output']; +}; +/** Represents a 'converted_note_to_issue' event on a given issue or pull request. */ +export type ConvertedNoteToIssueEvent = Node & { + __typename?: 'ConvertedNoteToIssueEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** Identifies the primary key from the database. */ + databaseId?: Maybe; + /** The Node ID of the ConvertedNoteToIssueEvent object */ + id: Scalars['ID']['output']; + /** Project referenced by event. */ + project?: Maybe; + /** Project card referenced by this project event. */ + projectCard?: Maybe; + /** Column name referenced by this project event. */ + projectColumnName: Scalars['String']['output']; +}; +/** Represents a 'converted_to_discussion' event on a given issue. */ +export type ConvertedToDiscussionEvent = Node & { + __typename?: 'ConvertedToDiscussionEvent'; + /** Identifies the actor who performed the event. */ + actor?: Maybe; + /** Identifies the date and time when the object was created. */ + createdAt: Scalars['DateTime']['output']; + /** The discussion that the issue was converted into. */ + discussion?: Maybe; + /** The Node ID of the ConvertedToDiscussionEvent object */ + id: Scalars['ID']['output']; +}; +/** Copilot endpoint information */ +export type CopilotEndpoints = { + __typename?: 'CopilotEndpoints'; + /** Copilot API endpoint */ + api: Scalars['String']['output']; + /** Copilot origin tracker endpoint */ + originTracker: Scalars['String']['output']; + /** Copilot proxy endpoint */ + proxy: Scalars['String']['output']; + /** Copilot telemetry endpoint */ + telemetry: Scalars['String']['output']; +}; +/** Autogenerated input type of CopyProjectV2 */ +export type CopyProjectV2Input = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** Include draft issues in the new project */ + includeDraftIssues?: InputMaybe; + /** The owner ID of the new project. */ + ownerId: Scalars['ID']['input']; + /** The ID of the source Project to copy. */ + projectId: Scalars['ID']['input']; + /** The title of the project. */ + title: Scalars['String']['input']; +}; +/** Autogenerated return type of CopyProjectV2. */ +export type CopyProjectV2Payload = { + __typename?: 'CopyProjectV2Payload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The copied project. */ + projectV2?: Maybe; +}; +/** Autogenerated input type of CreateAttributionInvitation */ +export type CreateAttributionInvitationInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The Node ID of the owner scoping the reattributable data. */ + ownerId: Scalars['ID']['input']; + /** The Node ID of the account owning the data to reattribute. */ + sourceId: Scalars['ID']['input']; + /** The Node ID of the account which may claim the data. */ + targetId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CreateAttributionInvitation. */ +export type CreateAttributionInvitationPayload = { + __typename?: 'CreateAttributionInvitationPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The owner scoping the reattributable data. */ + owner?: Maybe; + /** The account owning the data to reattribute. */ + source?: Maybe; + /** The account which may claim the data. */ + target?: Maybe; +}; +/** Autogenerated input type of CreateBranchProtectionRule */ +export type CreateBranchProtectionRuleInput = { + /** Can this branch be deleted. */ + allowsDeletions?: InputMaybe; + /** Are force pushes allowed on this branch. */ + allowsForcePushes?: InputMaybe; + /** Is branch creation a protected operation. */ + blocksCreations?: InputMaybe; + /** A list of User, Team, or App IDs allowed to bypass force push targeting matching branches. */ + bypassForcePushActorIds?: InputMaybe>; + /** A list of User, Team, or App IDs allowed to bypass pull requests targeting matching branches. */ + bypassPullRequestActorIds?: InputMaybe>; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** Will new commits pushed to matching branches dismiss pull request review approvals. */ + dismissesStaleReviews?: InputMaybe; + /** Can admins override branch protection. */ + isAdminEnforced?: InputMaybe; + /** + * Whether users can pull changes from upstream when the branch is locked. Set to + * `true` to allow fork syncing. Set to `false` to prevent fork syncing. + */ + lockAllowsFetchAndMerge?: InputMaybe; + /** Whether to set the branch as read-only. If this is true, users will not be able to push to the branch. */ + lockBranch?: InputMaybe; + /** The glob-like pattern used to determine matching branches. */ + pattern: Scalars['String']['input']; + /** A list of User, Team, or App IDs allowed to push to matching branches. */ + pushActorIds?: InputMaybe>; + /** The global relay id of the repository in which a new branch protection rule should be created in. */ + repositoryId: Scalars['ID']['input']; + /** Whether the most recent push must be approved by someone other than the person who pushed it */ + requireLastPushApproval?: InputMaybe; + /** Number of approving reviews required to update matching branches. */ + requiredApprovingReviewCount?: InputMaybe; + /** The list of required deployment environments */ + requiredDeploymentEnvironments?: InputMaybe>; + /** List of required status check contexts that must pass for commits to be accepted to matching branches. */ + requiredStatusCheckContexts?: InputMaybe>; + /** The list of required status checks */ + requiredStatusChecks?: InputMaybe>; + /** Are approving reviews required to update matching branches. */ + requiresApprovingReviews?: InputMaybe; + /** Are reviews from code owners required to update matching branches. */ + requiresCodeOwnerReviews?: InputMaybe; + /** Are commits required to be signed. */ + requiresCommitSignatures?: InputMaybe; + /** Are conversations required to be resolved before merging. */ + requiresConversationResolution?: InputMaybe; + /** Are successful deployments required before merging. */ + requiresDeployments?: InputMaybe; + /** Are merge commits prohibited from being pushed to this branch. */ + requiresLinearHistory?: InputMaybe; + /** Are status checks required to update matching branches. */ + requiresStatusChecks?: InputMaybe; + /** Are branches required to be up to date before merging. */ + requiresStrictStatusChecks?: InputMaybe; + /** Is pushing to matching branches restricted. */ + restrictsPushes?: InputMaybe; + /** Is dismissal of pull request reviews restricted. */ + restrictsReviewDismissals?: InputMaybe; + /** A list of User, Team, or App IDs allowed to dismiss reviews on pull requests targeting matching branches. */ + reviewDismissalActorIds?: InputMaybe>; +}; +/** Autogenerated return type of CreateBranchProtectionRule. */ +export type CreateBranchProtectionRulePayload = { + __typename?: 'CreateBranchProtectionRulePayload'; + /** The newly created BranchProtectionRule. */ + branchProtectionRule?: Maybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; +}; +/** Autogenerated input type of CreateCheckRun */ +export type CreateCheckRunInput = { + /** Possible further actions the integrator can perform, which a user may trigger. */ + actions?: InputMaybe>; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The time that the check run finished. */ + completedAt?: InputMaybe; + /** The final conclusion of the check. */ + conclusion?: InputMaybe; + /** The URL of the integrator's site that has the full details of the check. */ + detailsUrl?: InputMaybe; + /** A reference for the run on the integrator's system. */ + externalId?: InputMaybe; + /** The SHA of the head commit. */ + headSha: Scalars['GitObjectID']['input']; + /** The name of the check. */ + name: Scalars['String']['input']; + /** Descriptive details about the run. */ + output?: InputMaybe; + /** The node ID of the repository. */ + repositoryId: Scalars['ID']['input']; + /** The time that the check run began. */ + startedAt?: InputMaybe; + /** The current status. */ + status?: InputMaybe; +}; +/** Autogenerated return type of CreateCheckRun. */ +export type CreateCheckRunPayload = { + __typename?: 'CreateCheckRunPayload'; + /** The newly created check run. */ + checkRun?: Maybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; +}; +/** Autogenerated input type of CreateCheckSuite */ +export type CreateCheckSuiteInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The SHA of the head commit. */ + headSha: Scalars['GitObjectID']['input']; + /** The Node ID of the repository. */ + repositoryId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CreateCheckSuite. */ +export type CreateCheckSuitePayload = { + __typename?: 'CreateCheckSuitePayload'; + /** The newly created check suite. */ + checkSuite?: Maybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; +}; +/** Autogenerated input type of CreateCommitOnBranch */ +export type CreateCommitOnBranchInput = { + /** The Ref to be updated. Must be a branch. */ + branch: CommittableBranch; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The git commit oid expected at the head of the branch prior to the commit */ + expectedHeadOid: Scalars['GitObjectID']['input']; + /** A description of changes to files in this commit. */ + fileChanges?: InputMaybe; + /** The commit message the be included with the commit. */ + message: CommitMessage; +}; +/** Autogenerated return type of CreateCommitOnBranch. */ +export type CreateCommitOnBranchPayload = { + __typename?: 'CreateCommitOnBranchPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The new commit. */ + commit?: Maybe; + /** The ref which has been updated to point to the new commit. */ + ref?: Maybe; +}; +/** Autogenerated input type of CreateDeployment */ +export type CreateDeploymentInput = { + /** Attempt to automatically merge the default branch into the requested ref, defaults to true. */ + autoMerge?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** Short description of the deployment. */ + description?: InputMaybe; + /** Name for the target deployment environment. */ + environment?: InputMaybe; + /** JSON payload with extra information about the deployment. */ + payload?: InputMaybe; + /** The node ID of the ref to be deployed. */ + refId: Scalars['ID']['input']; + /** The node ID of the repository. */ + repositoryId: Scalars['ID']['input']; + /** + * The status contexts to verify against commit status checks. To bypass required + * contexts, pass an empty array. Defaults to all unique contexts. + */ + requiredContexts?: InputMaybe>; + /** Specifies a task to execute. */ + task?: InputMaybe; +}; +/** Autogenerated return type of CreateDeployment. */ +export type CreateDeploymentPayload = { + __typename?: 'CreateDeploymentPayload'; + /** True if the default branch has been auto-merged into the deployment ref. */ + autoMerged?: Maybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The new deployment. */ + deployment?: Maybe; +}; +/** Autogenerated input type of CreateDeploymentStatus */ +export type CreateDeploymentStatusInput = { + /** + * Adds a new inactive status to all non-transient, non-production environment + * deployments with the same repository and environment name as the created + * status's deployment. + */ + autoInactive?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The node ID of the deployment. */ + deploymentId: Scalars['ID']['input']; + /** A short description of the status. Maximum length of 140 characters. */ + description?: InputMaybe; + /** If provided, updates the environment of the deploy. Otherwise, does not modify the environment. */ + environment?: InputMaybe; + /** Sets the URL for accessing your environment. */ + environmentUrl?: InputMaybe; + /** + * The log URL to associate with this status. This URL should contain + * output to keep the user updated while the task is running or serve as + * historical information for what happened in the deployment. + */ + logUrl?: InputMaybe; + /** The state of the deployment. */ + state: DeploymentStatusState; +}; +/** Autogenerated return type of CreateDeploymentStatus. */ +export type CreateDeploymentStatusPayload = { + __typename?: 'CreateDeploymentStatusPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The new deployment status. */ + deploymentStatus?: Maybe; +}; +/** Autogenerated input type of CreateDiscussion */ +export type CreateDiscussionInput = { + /** The body of the discussion. */ + body: Scalars['String']['input']; + /** The id of the discussion category to associate with this discussion. */ + categoryId: Scalars['ID']['input']; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The id of the repository on which to create the discussion. */ + repositoryId: Scalars['ID']['input']; + /** The title of the discussion. */ + title: Scalars['String']['input']; +}; +/** Autogenerated return type of CreateDiscussion. */ +export type CreateDiscussionPayload = { + __typename?: 'CreateDiscussionPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The discussion that was just created. */ + discussion?: Maybe; +}; +/** Autogenerated input type of CreateEnterpriseOrganization */ +export type CreateEnterpriseOrganizationInput = { + /** The logins for the administrators of the new organization. */ + adminLogins: Array; + /** The email used for sending billing receipts. */ + billingEmail: Scalars['String']['input']; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The ID of the enterprise owning the new organization. */ + enterpriseId: Scalars['ID']['input']; + /** The login of the new organization. */ + login: Scalars['String']['input']; + /** The profile name of the new organization. */ + profileName: Scalars['String']['input']; +}; +/** Autogenerated return type of CreateEnterpriseOrganization. */ +export type CreateEnterpriseOrganizationPayload = { + __typename?: 'CreateEnterpriseOrganizationPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The enterprise that owns the created organization. */ + enterprise?: Maybe; + /** The organization that was created. */ + organization?: Maybe; +}; +/** Autogenerated input type of CreateEnvironment */ +export type CreateEnvironmentInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The name of the environment. */ + name: Scalars['String']['input']; + /** The node ID of the repository. */ + repositoryId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CreateEnvironment. */ +export type CreateEnvironmentPayload = { + __typename?: 'CreateEnvironmentPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The new or existing environment. */ + environment?: Maybe; +}; +/** Autogenerated input type of CreateIpAllowListEntry */ +export type CreateIpAllowListEntryInput = { + /** An IP address or range of addresses in CIDR notation. */ + allowListValue: Scalars['String']['input']; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** Whether the IP allow list entry is active when an IP allow list is enabled. */ + isActive: Scalars['Boolean']['input']; + /** An optional name for the IP allow list entry. */ + name?: InputMaybe; + /** The ID of the owner for which to create the new IP allow list entry. */ + ownerId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CreateIpAllowListEntry. */ +export type CreateIpAllowListEntryPayload = { + __typename?: 'CreateIpAllowListEntryPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The IP allow list entry that was created. */ + ipAllowListEntry?: Maybe; +}; +/** Autogenerated input type of CreateIssue */ +export type CreateIssueInput = { + /** The Node ID for the user assignee for this issue. */ + assigneeIds?: InputMaybe>; + /** The body for the issue description. */ + body?: InputMaybe; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** The name of an issue template in the repository, assigns labels and assignees from the template to the issue */ + issueTemplate?: InputMaybe; + /** An array of Node IDs of labels for this issue. */ + labelIds?: InputMaybe>; + /** The Node ID of the milestone for this issue. */ + milestoneId?: InputMaybe; + /** An array of Node IDs for projects associated with this issue. */ + projectIds?: InputMaybe>; + /** The Node ID of the repository. */ + repositoryId: Scalars['ID']['input']; + /** The title for the issue. */ + title: Scalars['String']['input']; +}; +/** Autogenerated return type of CreateIssue. */ +export type CreateIssuePayload = { + __typename?: 'CreateIssuePayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The new issue. */ + issue?: Maybe; +}; +/** Autogenerated input type of CreateLabel */ +export type CreateLabelInput = { + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: InputMaybe; + /** A 6 character hex code, without the leading #, identifying the color of the label. */ + color: Scalars['String']['input']; + /** A brief description of the label, such as its purpose. */ + description?: InputMaybe; + /** The name of the label. */ + name: Scalars['String']['input']; + /** The Node ID of the repository. */ + repositoryId: Scalars['ID']['input']; +}; +/** Autogenerated return type of CreateLabel. */ +export type CreateLabelPayload = { + __typename?: 'CreateLabelPayload'; + /** A unique identifier for the client performing the mutation. */ + clientMutationId?: Maybe; + /** The new label. */ + label?: Maybe