1import { gql } from '@apollo/client';
   2import * as Apollo from '@apollo/client';
   3export type Maybe<T> = T | null;
   4export type InputMaybe<T> = Maybe<T>;
   5export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
   6export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
   7export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
   8export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
   9export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
  10const defaultOptions = {} as const;
  11/** All built-in and custom scalars, mapped to their actual values */
  12export type Scalars = {
  13  ID: { input: string; output: string; }
  14  String: { input: string; output: string; }
  15  Boolean: { input: boolean; output: boolean; }
  16  Int: { input: number; output: number; }
  17  Float: { input: number; output: number; }
  18  CombinedId: { input: string; output: string; }
  19  Hash: { input: string; output: string; }
  20  Time: { input: string; output: string; }
  21};
  22
  23/** An object that has an author. */
  24export type Authored = {
  25  /** The author of this object. */
  26  author: Identity;
  27};
  28
  29export type Bug = Authored & {
  30  __typename?: 'Bug';
  31  /** The actors of the bug. Actors are Identity that have interacted with the bug. */
  32  actors: IdentityConnection;
  33  author: Identity;
  34  comments: BugCommentConnection;
  35  createdAt: Scalars['Time']['output'];
  36  /** The human version (truncated) identifier for this bug */
  37  humanId: Scalars['String']['output'];
  38  /** The identifier for this bug */
  39  id: Scalars['ID']['output'];
  40  labels: Array<Label>;
  41  lastEdit: Scalars['Time']['output'];
  42  operations: OperationConnection;
  43  /**
  44   * The participants of the bug. Participants are Identity that have created or
  45   * added a comment on the bug.
  46   */
  47  participants: IdentityConnection;
  48  status: Status;
  49  timeline: BugTimelineItemConnection;
  50  title: Scalars['String']['output'];
  51};
  52
  53
  54export type BugActorsArgs = {
  55  after?: InputMaybe<Scalars['String']['input']>;
  56  before?: InputMaybe<Scalars['String']['input']>;
  57  first?: InputMaybe<Scalars['Int']['input']>;
  58  last?: InputMaybe<Scalars['Int']['input']>;
  59};
  60
  61
  62export type BugCommentsArgs = {
  63  after?: InputMaybe<Scalars['String']['input']>;
  64  before?: InputMaybe<Scalars['String']['input']>;
  65  first?: InputMaybe<Scalars['Int']['input']>;
  66  last?: InputMaybe<Scalars['Int']['input']>;
  67};
  68
  69
  70export type BugOperationsArgs = {
  71  after?: InputMaybe<Scalars['String']['input']>;
  72  before?: InputMaybe<Scalars['String']['input']>;
  73  first?: InputMaybe<Scalars['Int']['input']>;
  74  last?: InputMaybe<Scalars['Int']['input']>;
  75};
  76
  77
  78export type BugParticipantsArgs = {
  79  after?: InputMaybe<Scalars['String']['input']>;
  80  before?: InputMaybe<Scalars['String']['input']>;
  81  first?: InputMaybe<Scalars['Int']['input']>;
  82  last?: InputMaybe<Scalars['Int']['input']>;
  83};
  84
  85
  86export type BugTimelineArgs = {
  87  after?: InputMaybe<Scalars['String']['input']>;
  88  before?: InputMaybe<Scalars['String']['input']>;
  89  first?: InputMaybe<Scalars['Int']['input']>;
  90  last?: InputMaybe<Scalars['Int']['input']>;
  91};
  92
  93export type BugAddCommentAndCloseInput = {
  94  /** A unique identifier for the client performing the mutation. */
  95  clientMutationId?: InputMaybe<Scalars['String']['input']>;
  96  /** The collection of file's hash required for the first message. */
  97  files?: InputMaybe<Array<Scalars['Hash']['input']>>;
  98  /** The message to be added to the bug. */
  99  message: Scalars['String']['input'];
 100  /** The bug ID's prefix. */
 101  prefix: Scalars['String']['input'];
 102  /** The name of the repository. If not set, the default repository is used. */
 103  repoRef?: InputMaybe<Scalars['String']['input']>;
 104};
 105
 106export type BugAddCommentAndClosePayload = {
 107  __typename?: 'BugAddCommentAndClosePayload';
 108  /** The affected bug. */
 109  bug: Bug;
 110  /** A unique identifier for the client performing the mutation. */
 111  clientMutationId?: Maybe<Scalars['String']['output']>;
 112  /** The resulting AddComment operation. */
 113  commentOperation: BugAddCommentOperation;
 114  /** The resulting SetStatusOperation. */
 115  statusOperation: BugSetStatusOperation;
 116};
 117
 118export type BugAddCommentAndReopenInput = {
 119  /** A unique identifier for the client performing the mutation. */
 120  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 121  /** The collection of file's hash required for the first message. */
 122  files?: InputMaybe<Array<Scalars['Hash']['input']>>;
 123  /** The message to be added to the bug. */
 124  message: Scalars['String']['input'];
 125  /** The bug ID's prefix. */
 126  prefix: Scalars['String']['input'];
 127  /** The name of the repository. If not set, the default repository is used. */
 128  repoRef?: InputMaybe<Scalars['String']['input']>;
 129};
 130
 131export type BugAddCommentAndReopenPayload = {
 132  __typename?: 'BugAddCommentAndReopenPayload';
 133  /** The affected bug. */
 134  bug: Bug;
 135  /** A unique identifier for the client performing the mutation. */
 136  clientMutationId?: Maybe<Scalars['String']['output']>;
 137  /** The resulting AddComment operation. */
 138  commentOperation: BugAddCommentOperation;
 139  /** The resulting SetStatusOperation. */
 140  statusOperation: BugSetStatusOperation;
 141};
 142
 143export type BugAddCommentInput = {
 144  /** A unique identifier for the client performing the mutation. */
 145  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 146  /** The collection of file's hash required for the first message. */
 147  files?: InputMaybe<Array<Scalars['Hash']['input']>>;
 148  /** The message to be added to the bug. */
 149  message: Scalars['String']['input'];
 150  /** The bug ID's prefix. */
 151  prefix: Scalars['String']['input'];
 152  /** The name of the repository. If not set, the default repository is used. */
 153  repoRef?: InputMaybe<Scalars['String']['input']>;
 154};
 155
 156export type BugAddCommentOperation = Authored & Operation & {
 157  __typename?: 'BugAddCommentOperation';
 158  /** The author of this object. */
 159  author: Identity;
 160  /** The datetime when this operation was issued. */
 161  date: Scalars['Time']['output'];
 162  files: Array<Scalars['Hash']['output']>;
 163  /** The identifier of the operation */
 164  id: Scalars['ID']['output'];
 165  message: Scalars['String']['output'];
 166};
 167
 168export type BugAddCommentPayload = {
 169  __typename?: 'BugAddCommentPayload';
 170  /** The affected bug. */
 171  bug: Bug;
 172  /** A unique identifier for the client performing the mutation. */
 173  clientMutationId?: Maybe<Scalars['String']['output']>;
 174  /** The resulting operation. */
 175  operation: BugAddCommentOperation;
 176};
 177
 178/** BugAddCommentTimelineItem is a BugTimelineItem that represent a BugComment and its edition history */
 179export type BugAddCommentTimelineItem = Authored & BugTimelineItem & {
 180  __typename?: 'BugAddCommentTimelineItem';
 181  author: Identity;
 182  createdAt: Scalars['Time']['output'];
 183  edited: Scalars['Boolean']['output'];
 184  files: Array<Scalars['Hash']['output']>;
 185  history: Array<BugCommentHistoryStep>;
 186  /** The identifier of the source operation */
 187  id: Scalars['CombinedId']['output'];
 188  lastEdit: Scalars['Time']['output'];
 189  message: Scalars['String']['output'];
 190  messageIsEmpty: Scalars['Boolean']['output'];
 191};
 192
 193export type BugChangeLabelInput = {
 194  /** The list of label to remove. */
 195  Removed?: InputMaybe<Array<Scalars['String']['input']>>;
 196  /** The list of label to add. */
 197  added?: InputMaybe<Array<Scalars['String']['input']>>;
 198  /** A unique identifier for the client performing the mutation. */
 199  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 200  /** The bug ID's prefix. */
 201  prefix: Scalars['String']['input'];
 202  /** The name of the repository. If not set, the default repository is used. */
 203  repoRef?: InputMaybe<Scalars['String']['input']>;
 204};
 205
 206export type BugChangeLabelPayload = {
 207  __typename?: 'BugChangeLabelPayload';
 208  /** The affected bug. */
 209  bug: Bug;
 210  /** A unique identifier for the client performing the mutation. */
 211  clientMutationId?: Maybe<Scalars['String']['output']>;
 212  /** The resulting operation. */
 213  operation: BugLabelChangeOperation;
 214  /** The effect each source label had. */
 215  results: Array<Maybe<LabelChangeResult>>;
 216};
 217
 218/** Represents a comment on a bug. */
 219export type BugComment = Authored & {
 220  __typename?: 'BugComment';
 221  /** The author of this comment. */
 222  author: Identity;
 223  /** All media's hash referenced in this comment */
 224  files: Array<Scalars['Hash']['output']>;
 225  id: Scalars['CombinedId']['output'];
 226  /** The message of this comment. */
 227  message: Scalars['String']['output'];
 228};
 229
 230export type BugCommentConnection = {
 231  __typename?: 'BugCommentConnection';
 232  edges: Array<BugCommentEdge>;
 233  nodes: Array<BugComment>;
 234  pageInfo: PageInfo;
 235  totalCount: Scalars['Int']['output'];
 236};
 237
 238export type BugCommentEdge = {
 239  __typename?: 'BugCommentEdge';
 240  cursor: Scalars['String']['output'];
 241  node: BugComment;
 242};
 243
 244/** CommentHistoryStep hold one version of a message in the history */
 245export type BugCommentHistoryStep = {
 246  __typename?: 'BugCommentHistoryStep';
 247  date: Scalars['Time']['output'];
 248  message: Scalars['String']['output'];
 249};
 250
 251/** The connection type for Bug. */
 252export type BugConnection = {
 253  __typename?: 'BugConnection';
 254  /** A list of edges. */
 255  edges: Array<BugEdge>;
 256  nodes: Array<Bug>;
 257  /** Information to aid in pagination. */
 258  pageInfo: PageInfo;
 259  /** Identifies the total count of items in the connection. */
 260  totalCount: Scalars['Int']['output'];
 261};
 262
 263export type BugCreateInput = {
 264  /** A unique identifier for the client performing the mutation. */
 265  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 266  /** The collection of file's hash required for the first message. */
 267  files?: InputMaybe<Array<Scalars['Hash']['input']>>;
 268  /** The first message of the new bug. */
 269  message: Scalars['String']['input'];
 270  /** The name of the repository. If not set, the default repository is used. */
 271  repoRef?: InputMaybe<Scalars['String']['input']>;
 272  /** The title of the new bug. */
 273  title: Scalars['String']['input'];
 274};
 275
 276export type BugCreateOperation = Authored & Operation & {
 277  __typename?: 'BugCreateOperation';
 278  /** The author of this object. */
 279  author: Identity;
 280  /** The datetime when this operation was issued. */
 281  date: Scalars['Time']['output'];
 282  files: Array<Scalars['Hash']['output']>;
 283  /** The identifier of the operation */
 284  id: Scalars['ID']['output'];
 285  message: Scalars['String']['output'];
 286  title: Scalars['String']['output'];
 287};
 288
 289export type BugCreatePayload = {
 290  __typename?: 'BugCreatePayload';
 291  /** The created bug. */
 292  bug: Bug;
 293  /** A unique identifier for the client performing the mutation. */
 294  clientMutationId?: Maybe<Scalars['String']['output']>;
 295  /** The resulting operation. */
 296  operation: BugCreateOperation;
 297};
 298
 299/** BugCreateTimelineItem is a BugTimelineItem that represent the creation of a bug and its message edition history */
 300export type BugCreateTimelineItem = Authored & BugTimelineItem & {
 301  __typename?: 'BugCreateTimelineItem';
 302  author: Identity;
 303  createdAt: Scalars['Time']['output'];
 304  edited: Scalars['Boolean']['output'];
 305  files: Array<Scalars['Hash']['output']>;
 306  history: Array<BugCommentHistoryStep>;
 307  /** The identifier of the source operation */
 308  id: Scalars['CombinedId']['output'];
 309  lastEdit: Scalars['Time']['output'];
 310  message: Scalars['String']['output'];
 311  messageIsEmpty: Scalars['Boolean']['output'];
 312};
 313
 314/** An edge in a connection. */
 315export type BugEdge = {
 316  __typename?: 'BugEdge';
 317  /** A cursor for use in pagination. */
 318  cursor: Scalars['String']['output'];
 319  /** The item at the end of the edge. */
 320  node: Bug;
 321};
 322
 323export type BugEditCommentInput = {
 324  /** A unique identifier for the client performing the mutation. */
 325  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 326  /** The collection of file's hash required for the first message. */
 327  files?: InputMaybe<Array<Scalars['Hash']['input']>>;
 328  /** The new message to be set. */
 329  message: Scalars['String']['input'];
 330  /** The name of the repository. If not set, the default repository is used. */
 331  repoRef?: InputMaybe<Scalars['String']['input']>;
 332  /** A prefix of the CombinedId of the comment to be changed. */
 333  targetPrefix: Scalars['String']['input'];
 334};
 335
 336export type BugEditCommentOperation = Authored & Operation & {
 337  __typename?: 'BugEditCommentOperation';
 338  /** The author of this object. */
 339  author: Identity;
 340  /** The datetime when this operation was issued. */
 341  date: Scalars['Time']['output'];
 342  files: Array<Scalars['Hash']['output']>;
 343  /** The identifier of the operation */
 344  id: Scalars['ID']['output'];
 345  message: Scalars['String']['output'];
 346  target: Scalars['String']['output'];
 347};
 348
 349export type BugEditCommentPayload = {
 350  __typename?: 'BugEditCommentPayload';
 351  /** The affected bug. */
 352  bug: Bug;
 353  /** A unique identifier for the client performing the mutation. */
 354  clientMutationId?: Maybe<Scalars['String']['output']>;
 355  /** The resulting operation. */
 356  operation: BugEditCommentOperation;
 357};
 358
 359export type BugLabelChangeOperation = Authored & Operation & {
 360  __typename?: 'BugLabelChangeOperation';
 361  added: Array<Label>;
 362  /** The author of this object. */
 363  author: Identity;
 364  /** The datetime when this operation was issued. */
 365  date: Scalars['Time']['output'];
 366  /** The identifier of the operation */
 367  id: Scalars['ID']['output'];
 368  removed: Array<Label>;
 369};
 370
 371/** BugLabelChangeTimelineItem is a BugTimelineItem that represent a change in the labels of a bug */
 372export type BugLabelChangeTimelineItem = Authored & BugTimelineItem & {
 373  __typename?: 'BugLabelChangeTimelineItem';
 374  added: Array<Label>;
 375  author: Identity;
 376  date: Scalars['Time']['output'];
 377  /** The identifier of the source operation */
 378  id: Scalars['CombinedId']['output'];
 379  removed: Array<Label>;
 380};
 381
 382export type BugSetStatusOperation = Authored & Operation & {
 383  __typename?: 'BugSetStatusOperation';
 384  /** The author of this object. */
 385  author: Identity;
 386  /** The datetime when this operation was issued. */
 387  date: Scalars['Time']['output'];
 388  /** The identifier of the operation */
 389  id: Scalars['ID']['output'];
 390  status: Status;
 391};
 392
 393/** BugSetStatusTimelineItem is a BugTimelineItem that represent a change in the status of a bug */
 394export type BugSetStatusTimelineItem = Authored & BugTimelineItem & {
 395  __typename?: 'BugSetStatusTimelineItem';
 396  author: Identity;
 397  date: Scalars['Time']['output'];
 398  /** The identifier of the source operation */
 399  id: Scalars['CombinedId']['output'];
 400  status: Status;
 401};
 402
 403export type BugSetTitleInput = {
 404  /** A unique identifier for the client performing the mutation. */
 405  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 406  /** The bug ID's prefix. */
 407  prefix: Scalars['String']['input'];
 408  /** The name of the repository. If not set, the default repository is used. */
 409  repoRef?: InputMaybe<Scalars['String']['input']>;
 410  /** The new title. */
 411  title: Scalars['String']['input'];
 412};
 413
 414export type BugSetTitleOperation = Authored & Operation & {
 415  __typename?: 'BugSetTitleOperation';
 416  /** The author of this object. */
 417  author: Identity;
 418  /** The datetime when this operation was issued. */
 419  date: Scalars['Time']['output'];
 420  /** The identifier of the operation */
 421  id: Scalars['ID']['output'];
 422  title: Scalars['String']['output'];
 423  was: Scalars['String']['output'];
 424};
 425
 426export type BugSetTitlePayload = {
 427  __typename?: 'BugSetTitlePayload';
 428  /** The affected bug. */
 429  bug: Bug;
 430  /** A unique identifier for the client performing the mutation. */
 431  clientMutationId?: Maybe<Scalars['String']['output']>;
 432  /** The resulting operation */
 433  operation: BugSetTitleOperation;
 434};
 435
 436/** BugLabelChangeTimelineItem is a BugTimelineItem that represent a change in the title of a bug */
 437export type BugSetTitleTimelineItem = Authored & BugTimelineItem & {
 438  __typename?: 'BugSetTitleTimelineItem';
 439  author: Identity;
 440  date: Scalars['Time']['output'];
 441  /** The identifier of the source operation */
 442  id: Scalars['CombinedId']['output'];
 443  title: Scalars['String']['output'];
 444  was: Scalars['String']['output'];
 445};
 446
 447export type BugStatusCloseInput = {
 448  /** A unique identifier for the client performing the mutation. */
 449  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 450  /** The bug ID's prefix. */
 451  prefix: Scalars['String']['input'];
 452  /** The name of the repository. If not set, the default repository is used. */
 453  repoRef?: InputMaybe<Scalars['String']['input']>;
 454};
 455
 456export type BugStatusClosePayload = {
 457  __typename?: 'BugStatusClosePayload';
 458  /** The affected bug. */
 459  bug: Bug;
 460  /** A unique identifier for the client performing the mutation. */
 461  clientMutationId?: Maybe<Scalars['String']['output']>;
 462  /** The resulting operation. */
 463  operation: BugSetStatusOperation;
 464};
 465
 466export type BugStatusOpenInput = {
 467  /** A unique identifier for the client performing the mutation. */
 468  clientMutationId?: InputMaybe<Scalars['String']['input']>;
 469  /** The bug ID's prefix. */
 470  prefix: Scalars['String']['input'];
 471  /** The name of the repository. If not set, the default repository is used. */
 472  repoRef?: InputMaybe<Scalars['String']['input']>;
 473};
 474
 475export type BugStatusOpenPayload = {
 476  __typename?: 'BugStatusOpenPayload';
 477  /** The affected bug. */
 478  bug: Bug;
 479  /** A unique identifier for the client performing the mutation. */
 480  clientMutationId?: Maybe<Scalars['String']['output']>;
 481  /** The resulting operation. */
 482  operation: BugSetStatusOperation;
 483};
 484
 485/** An item in the timeline of bug events */
 486export type BugTimelineItem = {
 487  /** The identifier of the source operation */
 488  id: Scalars['CombinedId']['output'];
 489};
 490
 491/** The connection type for TimelineItem */
 492export type BugTimelineItemConnection = {
 493  __typename?: 'BugTimelineItemConnection';
 494  edges: Array<BugTimelineItemEdge>;
 495  nodes: Array<BugTimelineItem>;
 496  pageInfo: PageInfo;
 497  totalCount: Scalars['Int']['output'];
 498};
 499
 500/** Represent a TimelineItem */
 501export type BugTimelineItemEdge = {
 502  __typename?: 'BugTimelineItemEdge';
 503  cursor: Scalars['String']['output'];
 504  node: BugTimelineItem;
 505};
 506
 507/** Defines a color by red, green and blue components. */
 508export type Color = {
 509  __typename?: 'Color';
 510  /** Blue component of the color. */
 511  B: Scalars['Int']['output'];
 512  /** Green component of the color. */
 513  G: Scalars['Int']['output'];
 514  /** Red component of the color. */
 515  R: Scalars['Int']['output'];
 516};
 517
 518/** Represents an identity */
 519export type Identity = {
 520  __typename?: 'Identity';
 521  /** An url to an avatar */
 522  avatarUrl?: Maybe<Scalars['String']['output']>;
 523  /** A non-empty string to display, representing the identity, based on the non-empty values. */
 524  displayName: Scalars['String']['output'];
 525  /** The email of the person, if known. */
 526  email?: Maybe<Scalars['String']['output']>;
 527  /** The human version (truncated) identifier for this identity */
 528  humanId: Scalars['String']['output'];
 529  /** The identifier for this identity */
 530  id: Scalars['ID']['output'];
 531  /**
 532   * isProtected is true if the chain of git commits started to be signed.
 533   * If that's the case, only signed commit with a valid key for this identity can be added.
 534   */
 535  isProtected: Scalars['Boolean']['output'];
 536  /** The login of the person, if known. */
 537  login?: Maybe<Scalars['String']['output']>;
 538  /** The name of the person, if known. */
 539  name?: Maybe<Scalars['String']['output']>;
 540};
 541
 542export type IdentityConnection = {
 543  __typename?: 'IdentityConnection';
 544  edges: Array<IdentityEdge>;
 545  nodes: Array<Identity>;
 546  pageInfo: PageInfo;
 547  totalCount: Scalars['Int']['output'];
 548};
 549
 550export type IdentityEdge = {
 551  __typename?: 'IdentityEdge';
 552  cursor: Scalars['String']['output'];
 553  node: Identity;
 554};
 555
 556/** Label for a bug. */
 557export type Label = {
 558  __typename?: 'Label';
 559  /** Color of the label. */
 560  color: Color;
 561  /** The name of the label. */
 562  name: Scalars['String']['output'];
 563};
 564
 565export type LabelChangeResult = {
 566  __typename?: 'LabelChangeResult';
 567  /** The source label. */
 568  label: Label;
 569  /** The effect this label had. */
 570  status: LabelChangeStatus;
 571};
 572
 573export enum LabelChangeStatus {
 574  Added = 'ADDED',
 575  AlreadySet = 'ALREADY_SET',
 576  DoesntExist = 'DOESNT_EXIST',
 577  DuplicateInOp = 'DUPLICATE_IN_OP',
 578  Removed = 'REMOVED'
 579}
 580
 581export type LabelConnection = {
 582  __typename?: 'LabelConnection';
 583  edges: Array<LabelEdge>;
 584  nodes: Array<Label>;
 585  pageInfo: PageInfo;
 586  totalCount: Scalars['Int']['output'];
 587};
 588
 589export type LabelEdge = {
 590  __typename?: 'LabelEdge';
 591  cursor: Scalars['String']['output'];
 592  node: Label;
 593};
 594
 595export type Mutation = {
 596  __typename?: 'Mutation';
 597  /** Add a new comment to a bug */
 598  bugAddComment: BugAddCommentPayload;
 599  /** Add a new comment to a bug and close it */
 600  bugAddCommentAndClose: BugAddCommentAndClosePayload;
 601  /** Add a new comment to a bug and reopen it */
 602  bugAddCommentAndReopen: BugAddCommentAndReopenPayload;
 603  /** Add or remove a set of label on a bug */
 604  bugChangeLabels: BugChangeLabelPayload;
 605  /** Create a new bug */
 606  bugCreate: BugCreatePayload;
 607  /** Change a comment of a bug */
 608  bugEditComment: BugEditCommentPayload;
 609  /** Change a bug's title */
 610  bugSetTitle: BugSetTitlePayload;
 611  /** Change a bug's status to closed */
 612  bugStatusClose: BugStatusClosePayload;
 613  /** Change a bug's status to open */
 614  bugStatusOpen: BugStatusOpenPayload;
 615};
 616
 617
 618export type MutationBugAddCommentArgs = {
 619  input: BugAddCommentInput;
 620};
 621
 622
 623export type MutationBugAddCommentAndCloseArgs = {
 624  input: BugAddCommentAndCloseInput;
 625};
 626
 627
 628export type MutationBugAddCommentAndReopenArgs = {
 629  input: BugAddCommentAndReopenInput;
 630};
 631
 632
 633export type MutationBugChangeLabelsArgs = {
 634  input?: InputMaybe<BugChangeLabelInput>;
 635};
 636
 637
 638export type MutationBugCreateArgs = {
 639  input: BugCreateInput;
 640};
 641
 642
 643export type MutationBugEditCommentArgs = {
 644  input: BugEditCommentInput;
 645};
 646
 647
 648export type MutationBugSetTitleArgs = {
 649  input: BugSetTitleInput;
 650};
 651
 652
 653export type MutationBugStatusCloseArgs = {
 654  input: BugStatusCloseInput;
 655};
 656
 657
 658export type MutationBugStatusOpenArgs = {
 659  input: BugStatusOpenInput;
 660};
 661
 662/** An operation applied to an entity. */
 663export type Operation = {
 664  /** The operations author. */
 665  author: Identity;
 666  /** The datetime when this operation was issued. */
 667  date: Scalars['Time']['output'];
 668  /** The identifier of the operation */
 669  id: Scalars['ID']['output'];
 670};
 671
 672/** The connection type for an Operation */
 673export type OperationConnection = {
 674  __typename?: 'OperationConnection';
 675  edges: Array<OperationEdge>;
 676  nodes: Array<Operation>;
 677  pageInfo: PageInfo;
 678  totalCount: Scalars['Int']['output'];
 679};
 680
 681/** Represent an Operation */
 682export type OperationEdge = {
 683  __typename?: 'OperationEdge';
 684  cursor: Scalars['String']['output'];
 685  node: Operation;
 686};
 687
 688/** Information about pagination in a connection. */
 689export type PageInfo = {
 690  __typename?: 'PageInfo';
 691  /** When paginating forwards, the cursor to continue. */
 692  endCursor: Scalars['String']['output'];
 693  /** When paginating forwards, are there more items? */
 694  hasNextPage: Scalars['Boolean']['output'];
 695  /** When paginating backwards, are there more items? */
 696  hasPreviousPage: Scalars['Boolean']['output'];
 697  /** When paginating backwards, the cursor to continue. */
 698  startCursor: Scalars['String']['output'];
 699};
 700
 701export type Query = {
 702  __typename?: 'Query';
 703  /** List all registered repositories. */
 704  repositories: RepositoryConnection;
 705  /** Access a repository by reference/name. If no ref is given, the default repository is returned if any. */
 706  repository?: Maybe<Repository>;
 707  /** Server configuration and authentication mode. */
 708  serverConfig: ServerConfig;
 709};
 710
 711
 712export type QueryRepositoriesArgs = {
 713  after?: InputMaybe<Scalars['String']['input']>;
 714  before?: InputMaybe<Scalars['String']['input']>;
 715  first?: InputMaybe<Scalars['Int']['input']>;
 716  last?: InputMaybe<Scalars['Int']['input']>;
 717};
 718
 719
 720export type QueryRepositoryArgs = {
 721  ref?: InputMaybe<Scalars['String']['input']>;
 722};
 723
 724export type Repository = {
 725  __typename?: 'Repository';
 726  /** All the bugs */
 727  allBugs: BugConnection;
 728  /** All the identities */
 729  allIdentities: IdentityConnection;
 730  bug?: Maybe<Bug>;
 731  identity?: Maybe<Identity>;
 732  /** The name of the repository */
 733  name?: Maybe<Scalars['String']['output']>;
 734  /**
 735   * URL-friendly slug for this repository. Named repos use their name;
 736   * the default (unnamed) repo derives the slug from the directory basename.
 737   */
 738  slug: Scalars['String']['output'];
 739  /** The identity created or selected by the user as its own */
 740  userIdentity?: Maybe<Identity>;
 741  /** List of valid labels. */
 742  validLabels: LabelConnection;
 743};
 744
 745
 746export type RepositoryAllBugsArgs = {
 747  after?: InputMaybe<Scalars['String']['input']>;
 748  before?: InputMaybe<Scalars['String']['input']>;
 749  first?: InputMaybe<Scalars['Int']['input']>;
 750  last?: InputMaybe<Scalars['Int']['input']>;
 751  query?: InputMaybe<Scalars['String']['input']>;
 752};
 753
 754
 755export type RepositoryAllIdentitiesArgs = {
 756  after?: InputMaybe<Scalars['String']['input']>;
 757  before?: InputMaybe<Scalars['String']['input']>;
 758  first?: InputMaybe<Scalars['Int']['input']>;
 759  last?: InputMaybe<Scalars['Int']['input']>;
 760};
 761
 762
 763export type RepositoryBugArgs = {
 764  prefix: Scalars['String']['input'];
 765};
 766
 767
 768export type RepositoryIdentityArgs = {
 769  prefix: Scalars['String']['input'];
 770};
 771
 772
 773export type RepositoryValidLabelsArgs = {
 774  after?: InputMaybe<Scalars['String']['input']>;
 775  before?: InputMaybe<Scalars['String']['input']>;
 776  first?: InputMaybe<Scalars['Int']['input']>;
 777  last?: InputMaybe<Scalars['Int']['input']>;
 778};
 779
 780export type RepositoryConnection = {
 781  __typename?: 'RepositoryConnection';
 782  edges: Array<RepositoryEdge>;
 783  nodes: Array<Repository>;
 784  pageInfo: PageInfo;
 785  totalCount: Scalars['Int']['output'];
 786};
 787
 788export type RepositoryEdge = {
 789  __typename?: 'RepositoryEdge';
 790  cursor: Scalars['String']['output'];
 791  node: Repository;
 792};
 793
 794/** Server-wide configuration, independent of any repository. */
 795export type ServerConfig = {
 796  __typename?: 'ServerConfig';
 797  /**
 798   * Authentication mode: 'local' (single user from git config),
 799   * 'oauth' (multi-user via external providers), or 'readonly'.
 800   */
 801  authMode: Scalars['String']['output'];
 802  /**
 803   * Names of the OAuth providers enabled on this server, e.g. ['github'].
 804   * Empty when authMode is not 'oauth'.
 805   */
 806  oauthProviders: Array<Scalars['String']['output']>;
 807};
 808
 809export enum Status {
 810  Closed = 'CLOSED',
 811  Open = 'OPEN'
 812}
 813
 814export type AllIdentitiesQueryVariables = Exact<{
 815  ref?: InputMaybe<Scalars['String']['input']>;
 816}>;
 817
 818
 819export type AllIdentitiesQuery = { __typename?: 'Query', repository?: { __typename?: 'Repository', allIdentities: { __typename?: 'IdentityConnection', nodes: Array<{ __typename?: 'Identity', id: string, humanId: string, name?: string | null, email?: string | null, login?: string | null, displayName: string, avatarUrl?: string | null }> } } | null };
 820
 821export type BugDetailQueryVariables = Exact<{
 822  ref?: InputMaybe<Scalars['String']['input']>;
 823  prefix: Scalars['String']['input'];
 824}>;
 825
 826
 827export type BugDetailQuery = { __typename?: 'Query', repository?: { __typename?: 'Repository', bug?: { __typename?: 'Bug', id: string, humanId: string, status: Status, title: string, createdAt: string, lastEdit: string, labels: Array<{ __typename?: 'Label', name: string, color: { __typename?: 'Color', R: number, G: number, B: number } }>, author: { __typename?: 'Identity', id: string, humanId: string, displayName: string, avatarUrl?: string | null }, participants: { __typename?: 'IdentityConnection', nodes: Array<{ __typename?: 'Identity', id: string, humanId: string, displayName: string, avatarUrl?: string | null }> }, timeline: { __typename?: 'BugTimelineItemConnection', nodes: Array<{ __typename: 'BugAddCommentTimelineItem', message: string, createdAt: string, lastEdit: string, edited: boolean, id: string, author: { __typename?: 'Identity', id: string, humanId: string, displayName: string, avatarUrl?: string | null } } | { __typename: 'BugCreateTimelineItem', message: string, createdAt: string, lastEdit: string, edited: boolean, id: string, author: { __typename?: 'Identity', id: string, humanId: string, displayName: string, avatarUrl?: string | null } } | { __typename: 'BugLabelChangeTimelineItem', date: string, id: string, author: { __typename?: 'Identity', humanId: string, displayName: string }, added: Array<{ __typename?: 'Label', name: string, color: { __typename?: 'Color', R: number, G: number, B: number } }>, removed: Array<{ __typename?: 'Label', name: string, color: { __typename?: 'Color', R: number, G: number, B: number } }> } | { __typename: 'BugSetStatusTimelineItem', date: string, status: Status, id: string, author: { __typename?: 'Identity', humanId: string, displayName: string } } | { __typename: 'BugSetTitleTimelineItem', date: string, title: string, was: string, id: string, author: { __typename?: 'Identity', humanId: string, displayName: string } }> } } | null } | null };
 828
 829export type BugListQueryVariables = Exact<{
 830  ref?: InputMaybe<Scalars['String']['input']>;
 831  query?: InputMaybe<Scalars['String']['input']>;
 832  first?: InputMaybe<Scalars['Int']['input']>;
 833  after?: InputMaybe<Scalars['String']['input']>;
 834}>;
 835
 836
 837export type BugListQuery = { __typename?: 'Query', repository?: { __typename?: 'Repository', allBugs: { __typename?: 'BugConnection', totalCount: number, pageInfo: { __typename?: 'PageInfo', hasNextPage: boolean, endCursor: string }, nodes: Array<{ __typename?: 'Bug', id: string, humanId: string, status: Status, title: string, createdAt: string, labels: Array<{ __typename?: 'Label', name: string, color: { __typename?: 'Color', R: number, G: number, B: number } }>, author: { __typename?: 'Identity', id: string, humanId: string, displayName: string, avatarUrl?: string | null }, comments: { __typename?: 'BugCommentConnection', totalCount: number } }> } } | null };
 838
 839export type BugCreateMutationVariables = Exact<{
 840  input: BugCreateInput;
 841}>;
 842
 843
 844export type BugCreateMutation = { __typename?: 'Mutation', bugCreate: { __typename?: 'BugCreatePayload', bug: { __typename?: 'Bug', id: string, humanId: string } } };
 845
 846export type BugAddCommentMutationVariables = Exact<{
 847  input: BugAddCommentInput;
 848}>;
 849
 850
 851export type BugAddCommentMutation = { __typename?: 'Mutation', bugAddComment: { __typename?: 'BugAddCommentPayload', bug: { __typename?: 'Bug', id: string } } };
 852
 853export type BugAddCommentAndCloseMutationVariables = Exact<{
 854  input: BugAddCommentAndCloseInput;
 855}>;
 856
 857
 858export type BugAddCommentAndCloseMutation = { __typename?: 'Mutation', bugAddCommentAndClose: { __typename?: 'BugAddCommentAndClosePayload', bug: { __typename?: 'Bug', id: string } } };
 859
 860export type BugAddCommentAndReopenMutationVariables = Exact<{
 861  input: BugAddCommentAndReopenInput;
 862}>;
 863
 864
 865export type BugAddCommentAndReopenMutation = { __typename?: 'Mutation', bugAddCommentAndReopen: { __typename?: 'BugAddCommentAndReopenPayload', bug: { __typename?: 'Bug', id: string } } };
 866
 867export type BugEditCommentMutationVariables = Exact<{
 868  input: BugEditCommentInput;
 869}>;
 870
 871
 872export type BugEditCommentMutation = { __typename?: 'Mutation', bugEditComment: { __typename?: 'BugEditCommentPayload', bug: { __typename?: 'Bug', id: string } } };
 873
 874export type BugChangeLabelsMutationVariables = Exact<{
 875  input?: InputMaybe<BugChangeLabelInput>;
 876}>;
 877
 878
 879export type BugChangeLabelsMutation = { __typename?: 'Mutation', bugChangeLabels: { __typename?: 'BugChangeLabelPayload', bug: { __typename?: 'Bug', id: string, labels: Array<{ __typename?: 'Label', name: string, color: { __typename?: 'Color', R: number, G: number, B: number } }> } } };
 880
 881export type BugStatusOpenMutationVariables = Exact<{
 882  input: BugStatusOpenInput;
 883}>;
 884
 885
 886export type BugStatusOpenMutation = { __typename?: 'Mutation', bugStatusOpen: { __typename?: 'BugStatusOpenPayload', bug: { __typename?: 'Bug', id: string, status: Status } } };
 887
 888export type BugStatusCloseMutationVariables = Exact<{
 889  input: BugStatusCloseInput;
 890}>;
 891
 892
 893export type BugStatusCloseMutation = { __typename?: 'Mutation', bugStatusClose: { __typename?: 'BugStatusClosePayload', bug: { __typename?: 'Bug', id: string, status: Status } } };
 894
 895export type BugSetTitleMutationVariables = Exact<{
 896  input: BugSetTitleInput;
 897}>;
 898
 899
 900export type BugSetTitleMutation = { __typename?: 'Mutation', bugSetTitle: { __typename?: 'BugSetTitlePayload', bug: { __typename?: 'Bug', id: string, title: string } } };
 901
 902export type RepositoriesQueryVariables = Exact<{ [key: string]: never; }>;
 903
 904
 905export type RepositoriesQuery = { __typename?: 'Query', repositories: { __typename?: 'RepositoryConnection', totalCount: number, nodes: Array<{ __typename?: 'Repository', name?: string | null, slug: string }> } };
 906
 907export type ServerConfigQueryVariables = Exact<{ [key: string]: never; }>;
 908
 909
 910export type ServerConfigQuery = { __typename?: 'Query', serverConfig: { __typename?: 'ServerConfig', authMode: string, oauthProviders: Array<string> } };
 911
 912export type UserProfileQueryVariables = Exact<{
 913  ref?: InputMaybe<Scalars['String']['input']>;
 914  prefix: Scalars['String']['input'];
 915  openQuery: Scalars['String']['input'];
 916  closedQuery: Scalars['String']['input'];
 917  listQuery: Scalars['String']['input'];
 918  after?: InputMaybe<Scalars['String']['input']>;
 919}>;
 920
 921
 922export type UserProfileQuery = { __typename?: 'Query', repository?: { __typename?: 'Repository', identity?: { __typename?: 'Identity', id: string, humanId: string, name?: string | null, email?: string | null, login?: string | null, displayName: string, avatarUrl?: string | null, isProtected: boolean } | null, openCount: { __typename?: 'BugConnection', totalCount: number }, closedCount: { __typename?: 'BugConnection', totalCount: number }, bugs: { __typename?: 'BugConnection', totalCount: number, pageInfo: { __typename?: 'PageInfo', hasNextPage: boolean, endCursor: string }, nodes: Array<{ __typename?: 'Bug', id: string, humanId: string, status: Status, title: string, createdAt: string, labels: Array<{ __typename?: 'Label', name: string, color: { __typename?: 'Color', R: number, G: number, B: number } }>, comments: { __typename?: 'BugCommentConnection', totalCount: number } }> } } | null };
 923
 924export type ValidLabelsQueryVariables = Exact<{
 925  ref?: InputMaybe<Scalars['String']['input']>;
 926}>;
 927
 928
 929export type ValidLabelsQuery = { __typename?: 'Query', repository?: { __typename?: 'Repository', validLabels: { __typename?: 'LabelConnection', nodes: Array<{ __typename?: 'Label', name: string, color: { __typename?: 'Color', R: number, G: number, B: number } }> } } | null };
 930
 931
 932export const AllIdentitiesDocument = gql`
 933    query AllIdentities($ref: String) {
 934  repository(ref: $ref) {
 935    allIdentities(first: 1000) {
 936      nodes {
 937        id
 938        humanId
 939        name
 940        email
 941        login
 942        displayName
 943        avatarUrl
 944      }
 945    }
 946  }
 947}
 948    `;
 949
 950/**
 951 * __useAllIdentitiesQuery__
 952 *
 953 * To run a query within a React component, call `useAllIdentitiesQuery` and pass it any options that fit your needs.
 954 * When your component renders, `useAllIdentitiesQuery` returns an object from Apollo Client that contains loading, error, and data properties
 955 * you can use to render your UI.
 956 *
 957 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
 958 *
 959 * @example
 960 * const { data, loading, error } = useAllIdentitiesQuery({
 961 *   variables: {
 962 *      ref: // value for 'ref'
 963 *   },
 964 * });
 965 */
 966export function useAllIdentitiesQuery(baseOptions?: Apollo.QueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
 967        const options = {...defaultOptions, ...baseOptions}
 968        return Apollo.useQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
 969      }
 970export function useAllIdentitiesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
 971          const options = {...defaultOptions, ...baseOptions}
 972          return Apollo.useLazyQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
 973        }
 974// @ts-ignore
 975export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>): Apollo.UseSuspenseQueryResult<AllIdentitiesQuery, AllIdentitiesQueryVariables>;
 976export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>): Apollo.UseSuspenseQueryResult<AllIdentitiesQuery | undefined, AllIdentitiesQueryVariables>;
 977export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
 978          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
 979          return Apollo.useSuspenseQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
 980        }
 981export type AllIdentitiesQueryHookResult = ReturnType<typeof useAllIdentitiesQuery>;
 982export type AllIdentitiesLazyQueryHookResult = ReturnType<typeof useAllIdentitiesLazyQuery>;
 983export type AllIdentitiesSuspenseQueryHookResult = ReturnType<typeof useAllIdentitiesSuspenseQuery>;
 984export type AllIdentitiesQueryResult = Apollo.QueryResult<AllIdentitiesQuery, AllIdentitiesQueryVariables>;
 985export const BugDetailDocument = gql`
 986    query BugDetail($ref: String, $prefix: String!) {
 987  repository(ref: $ref) {
 988    bug(prefix: $prefix) {
 989      id
 990      humanId
 991      status
 992      title
 993      labels {
 994        name
 995        color {
 996          R
 997          G
 998          B
 999        }
1000      }
1001      author {
1002        id
1003        humanId
1004        displayName
1005        avatarUrl
1006      }
1007      createdAt
1008      lastEdit
1009      participants(first: 20) {
1010        nodes {
1011          id
1012          humanId
1013          displayName
1014          avatarUrl
1015        }
1016      }
1017      timeline(first: 250) {
1018        nodes {
1019          __typename
1020          id
1021          ... on BugCreateTimelineItem {
1022            author {
1023              id
1024              humanId
1025              displayName
1026              avatarUrl
1027            }
1028            message
1029            createdAt
1030            lastEdit
1031            edited
1032          }
1033          ... on BugAddCommentTimelineItem {
1034            author {
1035              id
1036              humanId
1037              displayName
1038              avatarUrl
1039            }
1040            message
1041            createdAt
1042            lastEdit
1043            edited
1044          }
1045          ... on BugLabelChangeTimelineItem {
1046            author {
1047              humanId
1048              displayName
1049            }
1050            date
1051            added {
1052              name
1053              color {
1054                R
1055                G
1056                B
1057              }
1058            }
1059            removed {
1060              name
1061              color {
1062                R
1063                G
1064                B
1065              }
1066            }
1067          }
1068          ... on BugSetStatusTimelineItem {
1069            author {
1070              humanId
1071              displayName
1072            }
1073            date
1074            status
1075          }
1076          ... on BugSetTitleTimelineItem {
1077            author {
1078              humanId
1079              displayName
1080            }
1081            date
1082            title
1083            was
1084          }
1085        }
1086      }
1087    }
1088  }
1089}
1090    `;
1091
1092/**
1093 * __useBugDetailQuery__
1094 *
1095 * To run a query within a React component, call `useBugDetailQuery` and pass it any options that fit your needs.
1096 * When your component renders, `useBugDetailQuery` returns an object from Apollo Client that contains loading, error, and data properties
1097 * you can use to render your UI.
1098 *
1099 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
1100 *
1101 * @example
1102 * const { data, loading, error } = useBugDetailQuery({
1103 *   variables: {
1104 *      ref: // value for 'ref'
1105 *      prefix: // value for 'prefix'
1106 *   },
1107 * });
1108 */
1109export function useBugDetailQuery(baseOptions: Apollo.QueryHookOptions<BugDetailQuery, BugDetailQueryVariables> & ({ variables: BugDetailQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
1110        const options = {...defaultOptions, ...baseOptions}
1111        return Apollo.useQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1112      }
1113export function useBugDetailLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>) {
1114          const options = {...defaultOptions, ...baseOptions}
1115          return Apollo.useLazyQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1116        }
1117// @ts-ignore
1118export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>): Apollo.UseSuspenseQueryResult<BugDetailQuery, BugDetailQueryVariables>;
1119export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>): Apollo.UseSuspenseQueryResult<BugDetailQuery | undefined, BugDetailQueryVariables>;
1120export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>) {
1121          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1122          return Apollo.useSuspenseQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1123        }
1124export type BugDetailQueryHookResult = ReturnType<typeof useBugDetailQuery>;
1125export type BugDetailLazyQueryHookResult = ReturnType<typeof useBugDetailLazyQuery>;
1126export type BugDetailSuspenseQueryHookResult = ReturnType<typeof useBugDetailSuspenseQuery>;
1127export type BugDetailQueryResult = Apollo.QueryResult<BugDetailQuery, BugDetailQueryVariables>;
1128export const BugListDocument = gql`
1129    query BugList($ref: String, $query: String, $first: Int, $after: String) {
1130  repository(ref: $ref) {
1131    allBugs(query: $query, first: $first, after: $after) {
1132      totalCount
1133      pageInfo {
1134        hasNextPage
1135        endCursor
1136      }
1137      nodes {
1138        id
1139        humanId
1140        status
1141        title
1142        labels {
1143          name
1144          color {
1145            R
1146            G
1147            B
1148          }
1149        }
1150        author {
1151          id
1152          humanId
1153          displayName
1154          avatarUrl
1155        }
1156        createdAt
1157        comments {
1158          totalCount
1159        }
1160      }
1161    }
1162  }
1163}
1164    `;
1165
1166/**
1167 * __useBugListQuery__
1168 *
1169 * To run a query within a React component, call `useBugListQuery` and pass it any options that fit your needs.
1170 * When your component renders, `useBugListQuery` returns an object from Apollo Client that contains loading, error, and data properties
1171 * you can use to render your UI.
1172 *
1173 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
1174 *
1175 * @example
1176 * const { data, loading, error } = useBugListQuery({
1177 *   variables: {
1178 *      ref: // value for 'ref'
1179 *      query: // value for 'query'
1180 *      first: // value for 'first'
1181 *      after: // value for 'after'
1182 *   },
1183 * });
1184 */
1185export function useBugListQuery(baseOptions?: Apollo.QueryHookOptions<BugListQuery, BugListQueryVariables>) {
1186        const options = {...defaultOptions, ...baseOptions}
1187        return Apollo.useQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1188      }
1189export function useBugListLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BugListQuery, BugListQueryVariables>) {
1190          const options = {...defaultOptions, ...baseOptions}
1191          return Apollo.useLazyQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1192        }
1193// @ts-ignore
1194export function useBugListSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>): Apollo.UseSuspenseQueryResult<BugListQuery, BugListQueryVariables>;
1195export function useBugListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>): Apollo.UseSuspenseQueryResult<BugListQuery | undefined, BugListQueryVariables>;
1196export function useBugListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>) {
1197          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1198          return Apollo.useSuspenseQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1199        }
1200export type BugListQueryHookResult = ReturnType<typeof useBugListQuery>;
1201export type BugListLazyQueryHookResult = ReturnType<typeof useBugListLazyQuery>;
1202export type BugListSuspenseQueryHookResult = ReturnType<typeof useBugListSuspenseQuery>;
1203export type BugListQueryResult = Apollo.QueryResult<BugListQuery, BugListQueryVariables>;
1204export const BugCreateDocument = gql`
1205    mutation BugCreate($input: BugCreateInput!) {
1206  bugCreate(input: $input) {
1207    bug {
1208      id
1209      humanId
1210    }
1211  }
1212}
1213    `;
1214export type BugCreateMutationFn = Apollo.MutationFunction<BugCreateMutation, BugCreateMutationVariables>;
1215
1216/**
1217 * __useBugCreateMutation__
1218 *
1219 * To run a mutation, you first call `useBugCreateMutation` within a React component and pass it any options that fit your needs.
1220 * When your component renders, `useBugCreateMutation` returns a tuple that includes:
1221 * - A mutate function that you can call at any time to execute the mutation
1222 * - An object with fields that represent the current status of the mutation's execution
1223 *
1224 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1225 *
1226 * @example
1227 * const [bugCreateMutation, { data, loading, error }] = useBugCreateMutation({
1228 *   variables: {
1229 *      input: // value for 'input'
1230 *   },
1231 * });
1232 */
1233export function useBugCreateMutation(baseOptions?: Apollo.MutationHookOptions<BugCreateMutation, BugCreateMutationVariables>) {
1234        const options = {...defaultOptions, ...baseOptions}
1235        return Apollo.useMutation<BugCreateMutation, BugCreateMutationVariables>(BugCreateDocument, options);
1236      }
1237export type BugCreateMutationHookResult = ReturnType<typeof useBugCreateMutation>;
1238export type BugCreateMutationResult = Apollo.MutationResult<BugCreateMutation>;
1239export type BugCreateMutationOptions = Apollo.BaseMutationOptions<BugCreateMutation, BugCreateMutationVariables>;
1240export const BugAddCommentDocument = gql`
1241    mutation BugAddComment($input: BugAddCommentInput!) {
1242  bugAddComment(input: $input) {
1243    bug {
1244      id
1245    }
1246  }
1247}
1248    `;
1249export type BugAddCommentMutationFn = Apollo.MutationFunction<BugAddCommentMutation, BugAddCommentMutationVariables>;
1250
1251/**
1252 * __useBugAddCommentMutation__
1253 *
1254 * To run a mutation, you first call `useBugAddCommentMutation` within a React component and pass it any options that fit your needs.
1255 * When your component renders, `useBugAddCommentMutation` returns a tuple that includes:
1256 * - A mutate function that you can call at any time to execute the mutation
1257 * - An object with fields that represent the current status of the mutation's execution
1258 *
1259 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1260 *
1261 * @example
1262 * const [bugAddCommentMutation, { data, loading, error }] = useBugAddCommentMutation({
1263 *   variables: {
1264 *      input: // value for 'input'
1265 *   },
1266 * });
1267 */
1268export function useBugAddCommentMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentMutation, BugAddCommentMutationVariables>) {
1269        const options = {...defaultOptions, ...baseOptions}
1270        return Apollo.useMutation<BugAddCommentMutation, BugAddCommentMutationVariables>(BugAddCommentDocument, options);
1271      }
1272export type BugAddCommentMutationHookResult = ReturnType<typeof useBugAddCommentMutation>;
1273export type BugAddCommentMutationResult = Apollo.MutationResult<BugAddCommentMutation>;
1274export type BugAddCommentMutationOptions = Apollo.BaseMutationOptions<BugAddCommentMutation, BugAddCommentMutationVariables>;
1275export const BugAddCommentAndCloseDocument = gql`
1276    mutation BugAddCommentAndClose($input: BugAddCommentAndCloseInput!) {
1277  bugAddCommentAndClose(input: $input) {
1278    bug {
1279      id
1280    }
1281  }
1282}
1283    `;
1284export type BugAddCommentAndCloseMutationFn = Apollo.MutationFunction<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>;
1285
1286/**
1287 * __useBugAddCommentAndCloseMutation__
1288 *
1289 * To run a mutation, you first call `useBugAddCommentAndCloseMutation` within a React component and pass it any options that fit your needs.
1290 * When your component renders, `useBugAddCommentAndCloseMutation` returns a tuple that includes:
1291 * - A mutate function that you can call at any time to execute the mutation
1292 * - An object with fields that represent the current status of the mutation's execution
1293 *
1294 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1295 *
1296 * @example
1297 * const [bugAddCommentAndCloseMutation, { data, loading, error }] = useBugAddCommentAndCloseMutation({
1298 *   variables: {
1299 *      input: // value for 'input'
1300 *   },
1301 * });
1302 */
1303export function useBugAddCommentAndCloseMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>) {
1304        const options = {...defaultOptions, ...baseOptions}
1305        return Apollo.useMutation<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>(BugAddCommentAndCloseDocument, options);
1306      }
1307export type BugAddCommentAndCloseMutationHookResult = ReturnType<typeof useBugAddCommentAndCloseMutation>;
1308export type BugAddCommentAndCloseMutationResult = Apollo.MutationResult<BugAddCommentAndCloseMutation>;
1309export type BugAddCommentAndCloseMutationOptions = Apollo.BaseMutationOptions<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>;
1310export const BugAddCommentAndReopenDocument = gql`
1311    mutation BugAddCommentAndReopen($input: BugAddCommentAndReopenInput!) {
1312  bugAddCommentAndReopen(input: $input) {
1313    bug {
1314      id
1315    }
1316  }
1317}
1318    `;
1319export type BugAddCommentAndReopenMutationFn = Apollo.MutationFunction<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>;
1320
1321/**
1322 * __useBugAddCommentAndReopenMutation__
1323 *
1324 * To run a mutation, you first call `useBugAddCommentAndReopenMutation` within a React component and pass it any options that fit your needs.
1325 * When your component renders, `useBugAddCommentAndReopenMutation` returns a tuple that includes:
1326 * - A mutate function that you can call at any time to execute the mutation
1327 * - An object with fields that represent the current status of the mutation's execution
1328 *
1329 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1330 *
1331 * @example
1332 * const [bugAddCommentAndReopenMutation, { data, loading, error }] = useBugAddCommentAndReopenMutation({
1333 *   variables: {
1334 *      input: // value for 'input'
1335 *   },
1336 * });
1337 */
1338export function useBugAddCommentAndReopenMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>) {
1339        const options = {...defaultOptions, ...baseOptions}
1340        return Apollo.useMutation<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>(BugAddCommentAndReopenDocument, options);
1341      }
1342export type BugAddCommentAndReopenMutationHookResult = ReturnType<typeof useBugAddCommentAndReopenMutation>;
1343export type BugAddCommentAndReopenMutationResult = Apollo.MutationResult<BugAddCommentAndReopenMutation>;
1344export type BugAddCommentAndReopenMutationOptions = Apollo.BaseMutationOptions<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>;
1345export const BugEditCommentDocument = gql`
1346    mutation BugEditComment($input: BugEditCommentInput!) {
1347  bugEditComment(input: $input) {
1348    bug {
1349      id
1350    }
1351  }
1352}
1353    `;
1354export type BugEditCommentMutationFn = Apollo.MutationFunction<BugEditCommentMutation, BugEditCommentMutationVariables>;
1355
1356/**
1357 * __useBugEditCommentMutation__
1358 *
1359 * To run a mutation, you first call `useBugEditCommentMutation` within a React component and pass it any options that fit your needs.
1360 * When your component renders, `useBugEditCommentMutation` returns a tuple that includes:
1361 * - A mutate function that you can call at any time to execute the mutation
1362 * - An object with fields that represent the current status of the mutation's execution
1363 *
1364 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1365 *
1366 * @example
1367 * const [bugEditCommentMutation, { data, loading, error }] = useBugEditCommentMutation({
1368 *   variables: {
1369 *      input: // value for 'input'
1370 *   },
1371 * });
1372 */
1373export function useBugEditCommentMutation(baseOptions?: Apollo.MutationHookOptions<BugEditCommentMutation, BugEditCommentMutationVariables>) {
1374        const options = {...defaultOptions, ...baseOptions}
1375        return Apollo.useMutation<BugEditCommentMutation, BugEditCommentMutationVariables>(BugEditCommentDocument, options);
1376      }
1377export type BugEditCommentMutationHookResult = ReturnType<typeof useBugEditCommentMutation>;
1378export type BugEditCommentMutationResult = Apollo.MutationResult<BugEditCommentMutation>;
1379export type BugEditCommentMutationOptions = Apollo.BaseMutationOptions<BugEditCommentMutation, BugEditCommentMutationVariables>;
1380export const BugChangeLabelsDocument = gql`
1381    mutation BugChangeLabels($input: BugChangeLabelInput) {
1382  bugChangeLabels(input: $input) {
1383    bug {
1384      id
1385      labels {
1386        name
1387        color {
1388          R
1389          G
1390          B
1391        }
1392      }
1393    }
1394  }
1395}
1396    `;
1397export type BugChangeLabelsMutationFn = Apollo.MutationFunction<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>;
1398
1399/**
1400 * __useBugChangeLabelsMutation__
1401 *
1402 * To run a mutation, you first call `useBugChangeLabelsMutation` within a React component and pass it any options that fit your needs.
1403 * When your component renders, `useBugChangeLabelsMutation` returns a tuple that includes:
1404 * - A mutate function that you can call at any time to execute the mutation
1405 * - An object with fields that represent the current status of the mutation's execution
1406 *
1407 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1408 *
1409 * @example
1410 * const [bugChangeLabelsMutation, { data, loading, error }] = useBugChangeLabelsMutation({
1411 *   variables: {
1412 *      input: // value for 'input'
1413 *   },
1414 * });
1415 */
1416export function useBugChangeLabelsMutation(baseOptions?: Apollo.MutationHookOptions<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>) {
1417        const options = {...defaultOptions, ...baseOptions}
1418        return Apollo.useMutation<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>(BugChangeLabelsDocument, options);
1419      }
1420export type BugChangeLabelsMutationHookResult = ReturnType<typeof useBugChangeLabelsMutation>;
1421export type BugChangeLabelsMutationResult = Apollo.MutationResult<BugChangeLabelsMutation>;
1422export type BugChangeLabelsMutationOptions = Apollo.BaseMutationOptions<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>;
1423export const BugStatusOpenDocument = gql`
1424    mutation BugStatusOpen($input: BugStatusOpenInput!) {
1425  bugStatusOpen(input: $input) {
1426    bug {
1427      id
1428      status
1429    }
1430  }
1431}
1432    `;
1433export type BugStatusOpenMutationFn = Apollo.MutationFunction<BugStatusOpenMutation, BugStatusOpenMutationVariables>;
1434
1435/**
1436 * __useBugStatusOpenMutation__
1437 *
1438 * To run a mutation, you first call `useBugStatusOpenMutation` within a React component and pass it any options that fit your needs.
1439 * When your component renders, `useBugStatusOpenMutation` returns a tuple that includes:
1440 * - A mutate function that you can call at any time to execute the mutation
1441 * - An object with fields that represent the current status of the mutation's execution
1442 *
1443 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1444 *
1445 * @example
1446 * const [bugStatusOpenMutation, { data, loading, error }] = useBugStatusOpenMutation({
1447 *   variables: {
1448 *      input: // value for 'input'
1449 *   },
1450 * });
1451 */
1452export function useBugStatusOpenMutation(baseOptions?: Apollo.MutationHookOptions<BugStatusOpenMutation, BugStatusOpenMutationVariables>) {
1453        const options = {...defaultOptions, ...baseOptions}
1454        return Apollo.useMutation<BugStatusOpenMutation, BugStatusOpenMutationVariables>(BugStatusOpenDocument, options);
1455      }
1456export type BugStatusOpenMutationHookResult = ReturnType<typeof useBugStatusOpenMutation>;
1457export type BugStatusOpenMutationResult = Apollo.MutationResult<BugStatusOpenMutation>;
1458export type BugStatusOpenMutationOptions = Apollo.BaseMutationOptions<BugStatusOpenMutation, BugStatusOpenMutationVariables>;
1459export const BugStatusCloseDocument = gql`
1460    mutation BugStatusClose($input: BugStatusCloseInput!) {
1461  bugStatusClose(input: $input) {
1462    bug {
1463      id
1464      status
1465    }
1466  }
1467}
1468    `;
1469export type BugStatusCloseMutationFn = Apollo.MutationFunction<BugStatusCloseMutation, BugStatusCloseMutationVariables>;
1470
1471/**
1472 * __useBugStatusCloseMutation__
1473 *
1474 * To run a mutation, you first call `useBugStatusCloseMutation` within a React component and pass it any options that fit your needs.
1475 * When your component renders, `useBugStatusCloseMutation` returns a tuple that includes:
1476 * - A mutate function that you can call at any time to execute the mutation
1477 * - An object with fields that represent the current status of the mutation's execution
1478 *
1479 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1480 *
1481 * @example
1482 * const [bugStatusCloseMutation, { data, loading, error }] = useBugStatusCloseMutation({
1483 *   variables: {
1484 *      input: // value for 'input'
1485 *   },
1486 * });
1487 */
1488export function useBugStatusCloseMutation(baseOptions?: Apollo.MutationHookOptions<BugStatusCloseMutation, BugStatusCloseMutationVariables>) {
1489        const options = {...defaultOptions, ...baseOptions}
1490        return Apollo.useMutation<BugStatusCloseMutation, BugStatusCloseMutationVariables>(BugStatusCloseDocument, options);
1491      }
1492export type BugStatusCloseMutationHookResult = ReturnType<typeof useBugStatusCloseMutation>;
1493export type BugStatusCloseMutationResult = Apollo.MutationResult<BugStatusCloseMutation>;
1494export type BugStatusCloseMutationOptions = Apollo.BaseMutationOptions<BugStatusCloseMutation, BugStatusCloseMutationVariables>;
1495export const BugSetTitleDocument = gql`
1496    mutation BugSetTitle($input: BugSetTitleInput!) {
1497  bugSetTitle(input: $input) {
1498    bug {
1499      id
1500      title
1501    }
1502  }
1503}
1504    `;
1505export type BugSetTitleMutationFn = Apollo.MutationFunction<BugSetTitleMutation, BugSetTitleMutationVariables>;
1506
1507/**
1508 * __useBugSetTitleMutation__
1509 *
1510 * To run a mutation, you first call `useBugSetTitleMutation` within a React component and pass it any options that fit your needs.
1511 * When your component renders, `useBugSetTitleMutation` returns a tuple that includes:
1512 * - A mutate function that you can call at any time to execute the mutation
1513 * - An object with fields that represent the current status of the mutation's execution
1514 *
1515 * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1516 *
1517 * @example
1518 * const [bugSetTitleMutation, { data, loading, error }] = useBugSetTitleMutation({
1519 *   variables: {
1520 *      input: // value for 'input'
1521 *   },
1522 * });
1523 */
1524export function useBugSetTitleMutation(baseOptions?: Apollo.MutationHookOptions<BugSetTitleMutation, BugSetTitleMutationVariables>) {
1525        const options = {...defaultOptions, ...baseOptions}
1526        return Apollo.useMutation<BugSetTitleMutation, BugSetTitleMutationVariables>(BugSetTitleDocument, options);
1527      }
1528export type BugSetTitleMutationHookResult = ReturnType<typeof useBugSetTitleMutation>;
1529export type BugSetTitleMutationResult = Apollo.MutationResult<BugSetTitleMutation>;
1530export type BugSetTitleMutationOptions = Apollo.BaseMutationOptions<BugSetTitleMutation, BugSetTitleMutationVariables>;
1531export const RepositoriesDocument = gql`
1532    query Repositories {
1533  repositories {
1534    nodes {
1535      name
1536      slug
1537    }
1538    totalCount
1539  }
1540}
1541    `;
1542
1543/**
1544 * __useRepositoriesQuery__
1545 *
1546 * To run a query within a React component, call `useRepositoriesQuery` and pass it any options that fit your needs.
1547 * When your component renders, `useRepositoriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
1548 * you can use to render your UI.
1549 *
1550 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
1551 *
1552 * @example
1553 * const { data, loading, error } = useRepositoriesQuery({
1554 *   variables: {
1555 *   },
1556 * });
1557 */
1558export function useRepositoriesQuery(baseOptions?: Apollo.QueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1559        const options = {...defaultOptions, ...baseOptions}
1560        return Apollo.useQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1561      }
1562export function useRepositoriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1563          const options = {...defaultOptions, ...baseOptions}
1564          return Apollo.useLazyQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1565        }
1566// @ts-ignore
1567export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>): Apollo.UseSuspenseQueryResult<RepositoriesQuery, RepositoriesQueryVariables>;
1568export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>): Apollo.UseSuspenseQueryResult<RepositoriesQuery | undefined, RepositoriesQueryVariables>;
1569export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1570          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1571          return Apollo.useSuspenseQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1572        }
1573export type RepositoriesQueryHookResult = ReturnType<typeof useRepositoriesQuery>;
1574export type RepositoriesLazyQueryHookResult = ReturnType<typeof useRepositoriesLazyQuery>;
1575export type RepositoriesSuspenseQueryHookResult = ReturnType<typeof useRepositoriesSuspenseQuery>;
1576export type RepositoriesQueryResult = Apollo.QueryResult<RepositoriesQuery, RepositoriesQueryVariables>;
1577export const ServerConfigDocument = gql`
1578    query ServerConfig {
1579  serverConfig {
1580    authMode
1581    oauthProviders
1582  }
1583}
1584    `;
1585
1586/**
1587 * __useServerConfigQuery__
1588 *
1589 * To run a query within a React component, call `useServerConfigQuery` and pass it any options that fit your needs.
1590 * When your component renders, `useServerConfigQuery` returns an object from Apollo Client that contains loading, error, and data properties
1591 * you can use to render your UI.
1592 *
1593 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
1594 *
1595 * @example
1596 * const { data, loading, error } = useServerConfigQuery({
1597 *   variables: {
1598 *   },
1599 * });
1600 */
1601export function useServerConfigQuery(baseOptions?: Apollo.QueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1602        const options = {...defaultOptions, ...baseOptions}
1603        return Apollo.useQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1604      }
1605export function useServerConfigLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1606          const options = {...defaultOptions, ...baseOptions}
1607          return Apollo.useLazyQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1608        }
1609// @ts-ignore
1610export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>): Apollo.UseSuspenseQueryResult<ServerConfigQuery, ServerConfigQueryVariables>;
1611export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>): Apollo.UseSuspenseQueryResult<ServerConfigQuery | undefined, ServerConfigQueryVariables>;
1612export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1613          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1614          return Apollo.useSuspenseQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1615        }
1616export type ServerConfigQueryHookResult = ReturnType<typeof useServerConfigQuery>;
1617export type ServerConfigLazyQueryHookResult = ReturnType<typeof useServerConfigLazyQuery>;
1618export type ServerConfigSuspenseQueryHookResult = ReturnType<typeof useServerConfigSuspenseQuery>;
1619export type ServerConfigQueryResult = Apollo.QueryResult<ServerConfigQuery, ServerConfigQueryVariables>;
1620export const UserProfileDocument = gql`
1621    query UserProfile($ref: String, $prefix: String!, $openQuery: String!, $closedQuery: String!, $listQuery: String!, $after: String) {
1622  repository(ref: $ref) {
1623    identity(prefix: $prefix) {
1624      id
1625      humanId
1626      name
1627      email
1628      login
1629      displayName
1630      avatarUrl
1631      isProtected
1632    }
1633    openCount: allBugs(query: $openQuery, first: 1) {
1634      totalCount
1635    }
1636    closedCount: allBugs(query: $closedQuery, first: 1) {
1637      totalCount
1638    }
1639    bugs: allBugs(query: $listQuery, first: 25, after: $after) {
1640      totalCount
1641      pageInfo {
1642        hasNextPage
1643        endCursor
1644      }
1645      nodes {
1646        id
1647        humanId
1648        status
1649        title
1650        labels {
1651          name
1652          color {
1653            R
1654            G
1655            B
1656          }
1657        }
1658        createdAt
1659        comments {
1660          totalCount
1661        }
1662      }
1663    }
1664  }
1665}
1666    `;
1667
1668/**
1669 * __useUserProfileQuery__
1670 *
1671 * To run a query within a React component, call `useUserProfileQuery` and pass it any options that fit your needs.
1672 * When your component renders, `useUserProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
1673 * you can use to render your UI.
1674 *
1675 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
1676 *
1677 * @example
1678 * const { data, loading, error } = useUserProfileQuery({
1679 *   variables: {
1680 *      ref: // value for 'ref'
1681 *      prefix: // value for 'prefix'
1682 *      openQuery: // value for 'openQuery'
1683 *      closedQuery: // value for 'closedQuery'
1684 *      listQuery: // value for 'listQuery'
1685 *      after: // value for 'after'
1686 *   },
1687 * });
1688 */
1689export function useUserProfileQuery(baseOptions: Apollo.QueryHookOptions<UserProfileQuery, UserProfileQueryVariables> & ({ variables: UserProfileQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
1690        const options = {...defaultOptions, ...baseOptions}
1691        return Apollo.useQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1692      }
1693export function useUserProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {
1694          const options = {...defaultOptions, ...baseOptions}
1695          return Apollo.useLazyQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1696        }
1697// @ts-ignore
1698export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>): Apollo.UseSuspenseQueryResult<UserProfileQuery, UserProfileQueryVariables>;
1699export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>): Apollo.UseSuspenseQueryResult<UserProfileQuery | undefined, UserProfileQueryVariables>;
1700export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {
1701          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1702          return Apollo.useSuspenseQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1703        }
1704export type UserProfileQueryHookResult = ReturnType<typeof useUserProfileQuery>;
1705export type UserProfileLazyQueryHookResult = ReturnType<typeof useUserProfileLazyQuery>;
1706export type UserProfileSuspenseQueryHookResult = ReturnType<typeof useUserProfileSuspenseQuery>;
1707export type UserProfileQueryResult = Apollo.QueryResult<UserProfileQuery, UserProfileQueryVariables>;
1708export const ValidLabelsDocument = gql`
1709    query ValidLabels($ref: String) {
1710  repository(ref: $ref) {
1711    validLabels {
1712      nodes {
1713        name
1714        color {
1715          R
1716          G
1717          B
1718        }
1719      }
1720    }
1721  }
1722}
1723    `;
1724
1725/**
1726 * __useValidLabelsQuery__
1727 *
1728 * To run a query within a React component, call `useValidLabelsQuery` and pass it any options that fit your needs.
1729 * When your component renders, `useValidLabelsQuery` returns an object from Apollo Client that contains loading, error, and data properties
1730 * you can use to render your UI.
1731 *
1732 * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
1733 *
1734 * @example
1735 * const { data, loading, error } = useValidLabelsQuery({
1736 *   variables: {
1737 *      ref: // value for 'ref'
1738 *   },
1739 * });
1740 */
1741export function useValidLabelsQuery(baseOptions?: Apollo.QueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1742        const options = {...defaultOptions, ...baseOptions}
1743        return Apollo.useQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1744      }
1745export function useValidLabelsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1746          const options = {...defaultOptions, ...baseOptions}
1747          return Apollo.useLazyQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1748        }
1749// @ts-ignore
1750export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>): Apollo.UseSuspenseQueryResult<ValidLabelsQuery, ValidLabelsQueryVariables>;
1751export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>): Apollo.UseSuspenseQueryResult<ValidLabelsQuery | undefined, ValidLabelsQueryVariables>;
1752export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1753          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1754          return Apollo.useSuspenseQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1755        }
1756export type ValidLabelsQueryHookResult = ReturnType<typeof useValidLabelsQuery>;
1757export type ValidLabelsLazyQueryHookResult = ReturnType<typeof useValidLabelsLazyQuery>;
1758export type ValidLabelsSuspenseQueryHookResult = ReturnType<typeof useValidLabelsSuspenseQuery>;
1759export type ValidLabelsQueryResult = Apollo.QueryResult<ValidLabelsQuery, ValidLabelsQueryVariables>;