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 & Entity & {
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 BugEvent = {
360 __typename?: 'BugEvent';
361 bug: Bug;
362 type: EntityEventType;
363};
364
365export type BugLabelChangeOperation = Authored & Operation & {
366 __typename?: 'BugLabelChangeOperation';
367 added: Array<Label>;
368 /** The author of this object. */
369 author: Identity;
370 /** The datetime when this operation was issued. */
371 date: Scalars['Time']['output'];
372 /** The identifier of the operation */
373 id: Scalars['ID']['output'];
374 removed: Array<Label>;
375};
376
377/** BugLabelChangeTimelineItem is a BugTimelineItem that represent a change in the labels of a bug */
378export type BugLabelChangeTimelineItem = Authored & BugTimelineItem & {
379 __typename?: 'BugLabelChangeTimelineItem';
380 added: Array<Label>;
381 author: Identity;
382 date: Scalars['Time']['output'];
383 /** The identifier of the source operation */
384 id: Scalars['CombinedId']['output'];
385 removed: Array<Label>;
386};
387
388export type BugSetStatusOperation = Authored & Operation & {
389 __typename?: 'BugSetStatusOperation';
390 /** The author of this object. */
391 author: Identity;
392 /** The datetime when this operation was issued. */
393 date: Scalars['Time']['output'];
394 /** The identifier of the operation */
395 id: Scalars['ID']['output'];
396 status: Status;
397};
398
399/** BugSetStatusTimelineItem is a BugTimelineItem that represent a change in the status of a bug */
400export type BugSetStatusTimelineItem = Authored & BugTimelineItem & {
401 __typename?: 'BugSetStatusTimelineItem';
402 author: Identity;
403 date: Scalars['Time']['output'];
404 /** The identifier of the source operation */
405 id: Scalars['CombinedId']['output'];
406 status: Status;
407};
408
409export type BugSetTitleInput = {
410 /** A unique identifier for the client performing the mutation. */
411 clientMutationId?: InputMaybe<Scalars['String']['input']>;
412 /** The bug ID's prefix. */
413 prefix: Scalars['String']['input'];
414 /** The name of the repository. If not set, the default repository is used. */
415 repoRef?: InputMaybe<Scalars['String']['input']>;
416 /** The new title. */
417 title: Scalars['String']['input'];
418};
419
420export type BugSetTitleOperation = Authored & Operation & {
421 __typename?: 'BugSetTitleOperation';
422 /** The author of this object. */
423 author: Identity;
424 /** The datetime when this operation was issued. */
425 date: Scalars['Time']['output'];
426 /** The identifier of the operation */
427 id: Scalars['ID']['output'];
428 title: Scalars['String']['output'];
429 was: Scalars['String']['output'];
430};
431
432export type BugSetTitlePayload = {
433 __typename?: 'BugSetTitlePayload';
434 /** The affected bug. */
435 bug: Bug;
436 /** A unique identifier for the client performing the mutation. */
437 clientMutationId?: Maybe<Scalars['String']['output']>;
438 /** The resulting operation */
439 operation: BugSetTitleOperation;
440};
441
442/** BugLabelChangeTimelineItem is a BugTimelineItem that represent a change in the title of a bug */
443export type BugSetTitleTimelineItem = Authored & BugTimelineItem & {
444 __typename?: 'BugSetTitleTimelineItem';
445 author: Identity;
446 date: Scalars['Time']['output'];
447 /** The identifier of the source operation */
448 id: Scalars['CombinedId']['output'];
449 title: Scalars['String']['output'];
450 was: Scalars['String']['output'];
451};
452
453export type BugStatusCloseInput = {
454 /** A unique identifier for the client performing the mutation. */
455 clientMutationId?: InputMaybe<Scalars['String']['input']>;
456 /** The bug ID's prefix. */
457 prefix: Scalars['String']['input'];
458 /** The name of the repository. If not set, the default repository is used. */
459 repoRef?: InputMaybe<Scalars['String']['input']>;
460};
461
462export type BugStatusClosePayload = {
463 __typename?: 'BugStatusClosePayload';
464 /** The affected bug. */
465 bug: Bug;
466 /** A unique identifier for the client performing the mutation. */
467 clientMutationId?: Maybe<Scalars['String']['output']>;
468 /** The resulting operation. */
469 operation: BugSetStatusOperation;
470};
471
472export type BugStatusOpenInput = {
473 /** A unique identifier for the client performing the mutation. */
474 clientMutationId?: InputMaybe<Scalars['String']['input']>;
475 /** The bug ID's prefix. */
476 prefix: Scalars['String']['input'];
477 /** The name of the repository. If not set, the default repository is used. */
478 repoRef?: InputMaybe<Scalars['String']['input']>;
479};
480
481export type BugStatusOpenPayload = {
482 __typename?: 'BugStatusOpenPayload';
483 /** The affected bug. */
484 bug: Bug;
485 /** A unique identifier for the client performing the mutation. */
486 clientMutationId?: Maybe<Scalars['String']['output']>;
487 /** The resulting operation. */
488 operation: BugSetStatusOperation;
489};
490
491/** An item in the timeline of bug events */
492export type BugTimelineItem = {
493 /** The identifier of the source operation */
494 id: Scalars['CombinedId']['output'];
495};
496
497/** The connection type for TimelineItem */
498export type BugTimelineItemConnection = {
499 __typename?: 'BugTimelineItemConnection';
500 edges: Array<BugTimelineItemEdge>;
501 nodes: Array<BugTimelineItem>;
502 pageInfo: PageInfo;
503 totalCount: Scalars['Int']['output'];
504};
505
506/** Represent a TimelineItem */
507export type BugTimelineItemEdge = {
508 __typename?: 'BugTimelineItemEdge';
509 cursor: Scalars['String']['output'];
510 node: BugTimelineItem;
511};
512
513/** Defines a color by red, green and blue components. */
514export type Color = {
515 __typename?: 'Color';
516 /** Blue component of the color. */
517 B: Scalars['Int']['output'];
518 /** Green component of the color. */
519 G: Scalars['Int']['output'];
520 /** Red component of the color. */
521 R: Scalars['Int']['output'];
522};
523
524/** An entity (identity, bug, ...). */
525export type Entity = {
526 /** The human version (truncated) identifier for this entity */
527 humanId: Scalars['String']['output'];
528 /** The identifier for this entity */
529 id: Scalars['ID']['output'];
530};
531
532export type EntityEvent = {
533 __typename?: 'EntityEvent';
534 entity?: Maybe<Entity>;
535 type: EntityEventType;
536};
537
538export enum EntityEventType {
539 Created = 'CREATED',
540 Removed = 'REMOVED',
541 Updated = 'UPDATED'
542}
543
544/** Represents an identity */
545export type Identity = Entity & {
546 __typename?: 'Identity';
547 /** An url to an avatar */
548 avatarUrl?: Maybe<Scalars['String']['output']>;
549 /** A non-empty string to display, representing the identity, based on the non-empty values. */
550 displayName: Scalars['String']['output'];
551 /** The email of the person, if known. */
552 email?: Maybe<Scalars['String']['output']>;
553 /** The human version (truncated) identifier for this identity */
554 humanId: Scalars['String']['output'];
555 /** The identifier for this identity */
556 id: Scalars['ID']['output'];
557 /**
558 * isProtected is true if the chain of git commits started to be signed.
559 * If that's the case, only signed commit with a valid key for this identity can be added.
560 */
561 isProtected: Scalars['Boolean']['output'];
562 /** The login of the person, if known. */
563 login?: Maybe<Scalars['String']['output']>;
564 /** The name of the person, if known. */
565 name?: Maybe<Scalars['String']['output']>;
566};
567
568export type IdentityConnection = {
569 __typename?: 'IdentityConnection';
570 edges: Array<IdentityEdge>;
571 nodes: Array<Identity>;
572 pageInfo: PageInfo;
573 totalCount: Scalars['Int']['output'];
574};
575
576export type IdentityEdge = {
577 __typename?: 'IdentityEdge';
578 cursor: Scalars['String']['output'];
579 node: Identity;
580};
581
582export type IdentityEvent = {
583 __typename?: 'IdentityEvent';
584 identity: Identity;
585 type: EntityEventType;
586};
587
588/** Label for a bug. */
589export type Label = {
590 __typename?: 'Label';
591 /** Color of the label. */
592 color: Color;
593 /** The name of the label. */
594 name: Scalars['String']['output'];
595};
596
597export type LabelChangeResult = {
598 __typename?: 'LabelChangeResult';
599 /** The source label. */
600 label: Label;
601 /** The effect this label had. */
602 status: LabelChangeStatus;
603};
604
605export enum LabelChangeStatus {
606 Added = 'ADDED',
607 AlreadySet = 'ALREADY_SET',
608 DoesntExist = 'DOESNT_EXIST',
609 DuplicateInOp = 'DUPLICATE_IN_OP',
610 Removed = 'REMOVED'
611}
612
613export type LabelConnection = {
614 __typename?: 'LabelConnection';
615 edges: Array<LabelEdge>;
616 nodes: Array<Label>;
617 pageInfo: PageInfo;
618 totalCount: Scalars['Int']['output'];
619};
620
621export type LabelEdge = {
622 __typename?: 'LabelEdge';
623 cursor: Scalars['String']['output'];
624 node: Label;
625};
626
627export type Mutation = {
628 __typename?: 'Mutation';
629 /** Add a new comment to a bug */
630 bugAddComment: BugAddCommentPayload;
631 /** Add a new comment to a bug and close it */
632 bugAddCommentAndClose: BugAddCommentAndClosePayload;
633 /** Add a new comment to a bug and reopen it */
634 bugAddCommentAndReopen: BugAddCommentAndReopenPayload;
635 /** Add or remove a set of label on a bug */
636 bugChangeLabels: BugChangeLabelPayload;
637 /** Create a new bug */
638 bugCreate: BugCreatePayload;
639 /** Change a comment of a bug */
640 bugEditComment: BugEditCommentPayload;
641 /** Change a bug's title */
642 bugSetTitle: BugSetTitlePayload;
643 /** Change a bug's status to closed */
644 bugStatusClose: BugStatusClosePayload;
645 /** Change a bug's status to open */
646 bugStatusOpen: BugStatusOpenPayload;
647};
648
649
650export type MutationBugAddCommentArgs = {
651 input: BugAddCommentInput;
652};
653
654
655export type MutationBugAddCommentAndCloseArgs = {
656 input: BugAddCommentAndCloseInput;
657};
658
659
660export type MutationBugAddCommentAndReopenArgs = {
661 input: BugAddCommentAndReopenInput;
662};
663
664
665export type MutationBugChangeLabelsArgs = {
666 input?: InputMaybe<BugChangeLabelInput>;
667};
668
669
670export type MutationBugCreateArgs = {
671 input: BugCreateInput;
672};
673
674
675export type MutationBugEditCommentArgs = {
676 input: BugEditCommentInput;
677};
678
679
680export type MutationBugSetTitleArgs = {
681 input: BugSetTitleInput;
682};
683
684
685export type MutationBugStatusCloseArgs = {
686 input: BugStatusCloseInput;
687};
688
689
690export type MutationBugStatusOpenArgs = {
691 input: BugStatusOpenInput;
692};
693
694/** An operation applied to an entity. */
695export type Operation = {
696 /** The operations author. */
697 author: Identity;
698 /** The datetime when this operation was issued. */
699 date: Scalars['Time']['output'];
700 /** The identifier of the operation */
701 id: Scalars['ID']['output'];
702};
703
704/** The connection type for an Operation */
705export type OperationConnection = {
706 __typename?: 'OperationConnection';
707 edges: Array<OperationEdge>;
708 nodes: Array<Operation>;
709 pageInfo: PageInfo;
710 totalCount: Scalars['Int']['output'];
711};
712
713/** Represent an Operation */
714export type OperationEdge = {
715 __typename?: 'OperationEdge';
716 cursor: Scalars['String']['output'];
717 node: Operation;
718};
719
720/** Information about pagination in a connection. */
721export type PageInfo = {
722 __typename?: 'PageInfo';
723 /** When paginating forwards, the cursor to continue. */
724 endCursor: Scalars['String']['output'];
725 /** When paginating forwards, are there more items? */
726 hasNextPage: Scalars['Boolean']['output'];
727 /** When paginating backwards, are there more items? */
728 hasPreviousPage: Scalars['Boolean']['output'];
729 /** When paginating backwards, the cursor to continue. */
730 startCursor: Scalars['String']['output'];
731};
732
733export type Query = {
734 __typename?: 'Query';
735 /** List all registered repositories. */
736 repositories: RepositoryConnection;
737 /** Access a repository by reference/name. If no ref is given, the default repository is returned if any. */
738 repository?: Maybe<Repository>;
739 /** Server configuration and authentication mode. */
740 serverConfig: ServerConfig;
741};
742
743
744export type QueryRepositoriesArgs = {
745 after?: InputMaybe<Scalars['String']['input']>;
746 before?: InputMaybe<Scalars['String']['input']>;
747 first?: InputMaybe<Scalars['Int']['input']>;
748 last?: InputMaybe<Scalars['Int']['input']>;
749};
750
751
752export type QueryRepositoryArgs = {
753 ref?: InputMaybe<Scalars['String']['input']>;
754};
755
756export type Repository = {
757 __typename?: 'Repository';
758 /** All the bugs */
759 allBugs: BugConnection;
760 /** All the identities */
761 allIdentities: IdentityConnection;
762 bug?: Maybe<Bug>;
763 identity?: Maybe<Identity>;
764 /** The name of the repository. Null for the default (unnamed) repository. */
765 name?: Maybe<Scalars['String']['output']>;
766 /** The identity created or selected by the user as its own */
767 userIdentity?: Maybe<Identity>;
768 /** List of valid labels. */
769 validLabels: LabelConnection;
770};
771
772
773export type RepositoryAllBugsArgs = {
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 query?: InputMaybe<Scalars['String']['input']>;
779};
780
781
782export type RepositoryAllIdentitiesArgs = {
783 after?: InputMaybe<Scalars['String']['input']>;
784 before?: InputMaybe<Scalars['String']['input']>;
785 first?: InputMaybe<Scalars['Int']['input']>;
786 last?: InputMaybe<Scalars['Int']['input']>;
787};
788
789
790export type RepositoryBugArgs = {
791 prefix: Scalars['String']['input'];
792};
793
794
795export type RepositoryIdentityArgs = {
796 prefix: Scalars['String']['input'];
797};
798
799
800export type RepositoryValidLabelsArgs = {
801 after?: InputMaybe<Scalars['String']['input']>;
802 before?: InputMaybe<Scalars['String']['input']>;
803 first?: InputMaybe<Scalars['Int']['input']>;
804 last?: InputMaybe<Scalars['Int']['input']>;
805};
806
807export type RepositoryConnection = {
808 __typename?: 'RepositoryConnection';
809 edges: Array<RepositoryEdge>;
810 nodes: Array<Repository>;
811 pageInfo: PageInfo;
812 totalCount: Scalars['Int']['output'];
813};
814
815export type RepositoryEdge = {
816 __typename?: 'RepositoryEdge';
817 cursor: Scalars['String']['output'];
818 node: Repository;
819};
820
821/** Server-wide configuration, independent of any repository. */
822export type ServerConfig = {
823 __typename?: 'ServerConfig';
824 /**
825 * Authentication mode: 'local' (single user from git config),
826 * 'oauth' (multi-user via external providers), or 'readonly'.
827 */
828 authMode: Scalars['String']['output'];
829 /**
830 * Names of the OAuth providers enabled on this server, e.g. ['github'].
831 * Empty when authMode is not 'oauth'.
832 */
833 oauthProviders: Array<Scalars['String']['output']>;
834};
835
836export enum Status {
837 Closed = 'CLOSED',
838 Open = 'OPEN'
839}
840
841export type Subscription = {
842 __typename?: 'Subscription';
843 /** Subscribe to events on all entities. For events on a specific repo you can provide a repo reference. Without it, you get the unique default repo or all repo events. */
844 allEvents: EntityEvent;
845 /** Subscribe to bug entity events. For events on a specific repo you can provide a repo reference. Without it, you get the unique default repo or all repo events. */
846 bugEvents: BugEvent;
847 /** Subscribe to identity entity events. For events on a specific repo you can provide a repo reference. Without it, you get the unique default repo or all repo events. */
848 identityEvents: IdentityEvent;
849};
850
851
852export type SubscriptionAllEventsArgs = {
853 repoRef?: InputMaybe<Scalars['String']['input']>;
854 typename?: InputMaybe<Scalars['String']['input']>;
855};
856
857
858export type SubscriptionBugEventsArgs = {
859 repoRef?: InputMaybe<Scalars['String']['input']>;
860};
861
862
863export type SubscriptionIdentityEventsArgs = {
864 repoRef?: InputMaybe<Scalars['String']['input']>;
865};
866
867export type AllIdentitiesQueryVariables = Exact<{
868 ref?: InputMaybe<Scalars['String']['input']>;
869}>;
870
871
872export 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 };
873
874export type BugDetailQueryVariables = Exact<{
875 ref?: InputMaybe<Scalars['String']['input']>;
876 prefix: Scalars['String']['input'];
877}>;
878
879
880export 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 };
881
882export type BugListQueryVariables = Exact<{
883 ref?: InputMaybe<Scalars['String']['input']>;
884 query?: InputMaybe<Scalars['String']['input']>;
885 first?: InputMaybe<Scalars['Int']['input']>;
886 after?: InputMaybe<Scalars['String']['input']>;
887}>;
888
889
890export 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 };
891
892export type BugCreateMutationVariables = Exact<{
893 input: BugCreateInput;
894}>;
895
896
897export type BugCreateMutation = { __typename?: 'Mutation', bugCreate: { __typename?: 'BugCreatePayload', bug: { __typename?: 'Bug', id: string, humanId: string } } };
898
899export type BugAddCommentMutationVariables = Exact<{
900 input: BugAddCommentInput;
901}>;
902
903
904export type BugAddCommentMutation = { __typename?: 'Mutation', bugAddComment: { __typename?: 'BugAddCommentPayload', bug: { __typename?: 'Bug', id: string } } };
905
906export type BugAddCommentAndCloseMutationVariables = Exact<{
907 input: BugAddCommentAndCloseInput;
908}>;
909
910
911export type BugAddCommentAndCloseMutation = { __typename?: 'Mutation', bugAddCommentAndClose: { __typename?: 'BugAddCommentAndClosePayload', bug: { __typename?: 'Bug', id: string } } };
912
913export type BugAddCommentAndReopenMutationVariables = Exact<{
914 input: BugAddCommentAndReopenInput;
915}>;
916
917
918export type BugAddCommentAndReopenMutation = { __typename?: 'Mutation', bugAddCommentAndReopen: { __typename?: 'BugAddCommentAndReopenPayload', bug: { __typename?: 'Bug', id: string } } };
919
920export type BugEditCommentMutationVariables = Exact<{
921 input: BugEditCommentInput;
922}>;
923
924
925export type BugEditCommentMutation = { __typename?: 'Mutation', bugEditComment: { __typename?: 'BugEditCommentPayload', bug: { __typename?: 'Bug', id: string } } };
926
927export type BugChangeLabelsMutationVariables = Exact<{
928 input?: InputMaybe<BugChangeLabelInput>;
929}>;
930
931
932export 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 } }> } } };
933
934export type BugStatusOpenMutationVariables = Exact<{
935 input: BugStatusOpenInput;
936}>;
937
938
939export type BugStatusOpenMutation = { __typename?: 'Mutation', bugStatusOpen: { __typename?: 'BugStatusOpenPayload', bug: { __typename?: 'Bug', id: string, status: Status } } };
940
941export type BugStatusCloseMutationVariables = Exact<{
942 input: BugStatusCloseInput;
943}>;
944
945
946export type BugStatusCloseMutation = { __typename?: 'Mutation', bugStatusClose: { __typename?: 'BugStatusClosePayload', bug: { __typename?: 'Bug', id: string, status: Status } } };
947
948export type BugSetTitleMutationVariables = Exact<{
949 input: BugSetTitleInput;
950}>;
951
952
953export type BugSetTitleMutation = { __typename?: 'Mutation', bugSetTitle: { __typename?: 'BugSetTitlePayload', bug: { __typename?: 'Bug', id: string, title: string } } };
954
955export type RepositoriesQueryVariables = Exact<{ [key: string]: never; }>;
956
957
958export type RepositoriesQuery = { __typename?: 'Query', repositories: { __typename?: 'RepositoryConnection', totalCount: number, nodes: Array<{ __typename?: 'Repository', name?: string | null }> } };
959
960export type ServerConfigQueryVariables = Exact<{ [key: string]: never; }>;
961
962
963export type ServerConfigQuery = { __typename?: 'Query', serverConfig: { __typename?: 'ServerConfig', authMode: string, oauthProviders: Array<string> } };
964
965export type UserProfileQueryVariables = Exact<{
966 ref?: InputMaybe<Scalars['String']['input']>;
967 prefix: Scalars['String']['input'];
968 openQuery: Scalars['String']['input'];
969 closedQuery: Scalars['String']['input'];
970 listQuery: Scalars['String']['input'];
971 after?: InputMaybe<Scalars['String']['input']>;
972}>;
973
974
975export 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 };
976
977export type ValidLabelsQueryVariables = Exact<{
978 ref?: InputMaybe<Scalars['String']['input']>;
979}>;
980
981
982export 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 };
983
984
985export const AllIdentitiesDocument = gql`
986 query AllIdentities($ref: String) {
987 repository(ref: $ref) {
988 allIdentities(first: 1000) {
989 nodes {
990 id
991 humanId
992 name
993 email
994 login
995 displayName
996 avatarUrl
997 }
998 }
999 }
1000}
1001 `;
1002
1003/**
1004 * __useAllIdentitiesQuery__
1005 *
1006 * To run a query within a React component, call `useAllIdentitiesQuery` and pass it any options that fit your needs.
1007 * When your component renders, `useAllIdentitiesQuery` returns an object from Apollo Client that contains loading, error, and data properties
1008 * you can use to render your UI.
1009 *
1010 * @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;
1011 *
1012 * @example
1013 * const { data, loading, error } = useAllIdentitiesQuery({
1014 * variables: {
1015 * ref: // value for 'ref'
1016 * },
1017 * });
1018 */
1019export function useAllIdentitiesQuery(baseOptions?: Apollo.QueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
1020 const options = {...defaultOptions, ...baseOptions}
1021 return Apollo.useQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
1022 }
1023export function useAllIdentitiesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
1024 const options = {...defaultOptions, ...baseOptions}
1025 return Apollo.useLazyQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
1026 }
1027// @ts-ignore
1028export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>): Apollo.UseSuspenseQueryResult<AllIdentitiesQuery, AllIdentitiesQueryVariables>;
1029export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>): Apollo.UseSuspenseQueryResult<AllIdentitiesQuery | undefined, AllIdentitiesQueryVariables>;
1030export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
1031 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1032 return Apollo.useSuspenseQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
1033 }
1034export type AllIdentitiesQueryHookResult = ReturnType<typeof useAllIdentitiesQuery>;
1035export type AllIdentitiesLazyQueryHookResult = ReturnType<typeof useAllIdentitiesLazyQuery>;
1036export type AllIdentitiesSuspenseQueryHookResult = ReturnType<typeof useAllIdentitiesSuspenseQuery>;
1037export type AllIdentitiesQueryResult = Apollo.QueryResult<AllIdentitiesQuery, AllIdentitiesQueryVariables>;
1038export const BugDetailDocument = gql`
1039 query BugDetail($ref: String, $prefix: String!) {
1040 repository(ref: $ref) {
1041 bug(prefix: $prefix) {
1042 id
1043 humanId
1044 status
1045 title
1046 labels {
1047 name
1048 color {
1049 R
1050 G
1051 B
1052 }
1053 }
1054 author {
1055 id
1056 humanId
1057 displayName
1058 avatarUrl
1059 }
1060 createdAt
1061 lastEdit
1062 participants(first: 20) {
1063 nodes {
1064 id
1065 humanId
1066 displayName
1067 avatarUrl
1068 }
1069 }
1070 timeline(first: 250) {
1071 nodes {
1072 __typename
1073 id
1074 ... on BugCreateTimelineItem {
1075 author {
1076 id
1077 humanId
1078 displayName
1079 avatarUrl
1080 }
1081 message
1082 createdAt
1083 lastEdit
1084 edited
1085 }
1086 ... on BugAddCommentTimelineItem {
1087 author {
1088 id
1089 humanId
1090 displayName
1091 avatarUrl
1092 }
1093 message
1094 createdAt
1095 lastEdit
1096 edited
1097 }
1098 ... on BugLabelChangeTimelineItem {
1099 author {
1100 humanId
1101 displayName
1102 }
1103 date
1104 added {
1105 name
1106 color {
1107 R
1108 G
1109 B
1110 }
1111 }
1112 removed {
1113 name
1114 color {
1115 R
1116 G
1117 B
1118 }
1119 }
1120 }
1121 ... on BugSetStatusTimelineItem {
1122 author {
1123 humanId
1124 displayName
1125 }
1126 date
1127 status
1128 }
1129 ... on BugSetTitleTimelineItem {
1130 author {
1131 humanId
1132 displayName
1133 }
1134 date
1135 title
1136 was
1137 }
1138 }
1139 }
1140 }
1141 }
1142}
1143 `;
1144
1145/**
1146 * __useBugDetailQuery__
1147 *
1148 * To run a query within a React component, call `useBugDetailQuery` and pass it any options that fit your needs.
1149 * When your component renders, `useBugDetailQuery` returns an object from Apollo Client that contains loading, error, and data properties
1150 * you can use to render your UI.
1151 *
1152 * @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;
1153 *
1154 * @example
1155 * const { data, loading, error } = useBugDetailQuery({
1156 * variables: {
1157 * ref: // value for 'ref'
1158 * prefix: // value for 'prefix'
1159 * },
1160 * });
1161 */
1162export function useBugDetailQuery(baseOptions: Apollo.QueryHookOptions<BugDetailQuery, BugDetailQueryVariables> & ({ variables: BugDetailQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
1163 const options = {...defaultOptions, ...baseOptions}
1164 return Apollo.useQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1165 }
1166export function useBugDetailLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>) {
1167 const options = {...defaultOptions, ...baseOptions}
1168 return Apollo.useLazyQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1169 }
1170// @ts-ignore
1171export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>): Apollo.UseSuspenseQueryResult<BugDetailQuery, BugDetailQueryVariables>;
1172export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>): Apollo.UseSuspenseQueryResult<BugDetailQuery | undefined, BugDetailQueryVariables>;
1173export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>) {
1174 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1175 return Apollo.useSuspenseQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1176 }
1177export type BugDetailQueryHookResult = ReturnType<typeof useBugDetailQuery>;
1178export type BugDetailLazyQueryHookResult = ReturnType<typeof useBugDetailLazyQuery>;
1179export type BugDetailSuspenseQueryHookResult = ReturnType<typeof useBugDetailSuspenseQuery>;
1180export type BugDetailQueryResult = Apollo.QueryResult<BugDetailQuery, BugDetailQueryVariables>;
1181export const BugListDocument = gql`
1182 query BugList($ref: String, $query: String, $first: Int, $after: String) {
1183 repository(ref: $ref) {
1184 allBugs(query: $query, first: $first, after: $after) {
1185 totalCount
1186 pageInfo {
1187 hasNextPage
1188 endCursor
1189 }
1190 nodes {
1191 id
1192 humanId
1193 status
1194 title
1195 labels {
1196 name
1197 color {
1198 R
1199 G
1200 B
1201 }
1202 }
1203 author {
1204 id
1205 humanId
1206 displayName
1207 avatarUrl
1208 }
1209 createdAt
1210 comments {
1211 totalCount
1212 }
1213 }
1214 }
1215 }
1216}
1217 `;
1218
1219/**
1220 * __useBugListQuery__
1221 *
1222 * To run a query within a React component, call `useBugListQuery` and pass it any options that fit your needs.
1223 * When your component renders, `useBugListQuery` returns an object from Apollo Client that contains loading, error, and data properties
1224 * you can use to render your UI.
1225 *
1226 * @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;
1227 *
1228 * @example
1229 * const { data, loading, error } = useBugListQuery({
1230 * variables: {
1231 * ref: // value for 'ref'
1232 * query: // value for 'query'
1233 * first: // value for 'first'
1234 * after: // value for 'after'
1235 * },
1236 * });
1237 */
1238export function useBugListQuery(baseOptions?: Apollo.QueryHookOptions<BugListQuery, BugListQueryVariables>) {
1239 const options = {...defaultOptions, ...baseOptions}
1240 return Apollo.useQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1241 }
1242export function useBugListLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BugListQuery, BugListQueryVariables>) {
1243 const options = {...defaultOptions, ...baseOptions}
1244 return Apollo.useLazyQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1245 }
1246// @ts-ignore
1247export function useBugListSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>): Apollo.UseSuspenseQueryResult<BugListQuery, BugListQueryVariables>;
1248export function useBugListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>): Apollo.UseSuspenseQueryResult<BugListQuery | undefined, BugListQueryVariables>;
1249export function useBugListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>) {
1250 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1251 return Apollo.useSuspenseQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1252 }
1253export type BugListQueryHookResult = ReturnType<typeof useBugListQuery>;
1254export type BugListLazyQueryHookResult = ReturnType<typeof useBugListLazyQuery>;
1255export type BugListSuspenseQueryHookResult = ReturnType<typeof useBugListSuspenseQuery>;
1256export type BugListQueryResult = Apollo.QueryResult<BugListQuery, BugListQueryVariables>;
1257export const BugCreateDocument = gql`
1258 mutation BugCreate($input: BugCreateInput!) {
1259 bugCreate(input: $input) {
1260 bug {
1261 id
1262 humanId
1263 }
1264 }
1265}
1266 `;
1267export type BugCreateMutationFn = Apollo.MutationFunction<BugCreateMutation, BugCreateMutationVariables>;
1268
1269/**
1270 * __useBugCreateMutation__
1271 *
1272 * To run a mutation, you first call `useBugCreateMutation` within a React component and pass it any options that fit your needs.
1273 * When your component renders, `useBugCreateMutation` returns a tuple that includes:
1274 * - A mutate function that you can call at any time to execute the mutation
1275 * - An object with fields that represent the current status of the mutation's execution
1276 *
1277 * @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;
1278 *
1279 * @example
1280 * const [bugCreateMutation, { data, loading, error }] = useBugCreateMutation({
1281 * variables: {
1282 * input: // value for 'input'
1283 * },
1284 * });
1285 */
1286export function useBugCreateMutation(baseOptions?: Apollo.MutationHookOptions<BugCreateMutation, BugCreateMutationVariables>) {
1287 const options = {...defaultOptions, ...baseOptions}
1288 return Apollo.useMutation<BugCreateMutation, BugCreateMutationVariables>(BugCreateDocument, options);
1289 }
1290export type BugCreateMutationHookResult = ReturnType<typeof useBugCreateMutation>;
1291export type BugCreateMutationResult = Apollo.MutationResult<BugCreateMutation>;
1292export type BugCreateMutationOptions = Apollo.BaseMutationOptions<BugCreateMutation, BugCreateMutationVariables>;
1293export const BugAddCommentDocument = gql`
1294 mutation BugAddComment($input: BugAddCommentInput!) {
1295 bugAddComment(input: $input) {
1296 bug {
1297 id
1298 }
1299 }
1300}
1301 `;
1302export type BugAddCommentMutationFn = Apollo.MutationFunction<BugAddCommentMutation, BugAddCommentMutationVariables>;
1303
1304/**
1305 * __useBugAddCommentMutation__
1306 *
1307 * To run a mutation, you first call `useBugAddCommentMutation` within a React component and pass it any options that fit your needs.
1308 * When your component renders, `useBugAddCommentMutation` returns a tuple that includes:
1309 * - A mutate function that you can call at any time to execute the mutation
1310 * - An object with fields that represent the current status of the mutation's execution
1311 *
1312 * @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;
1313 *
1314 * @example
1315 * const [bugAddCommentMutation, { data, loading, error }] = useBugAddCommentMutation({
1316 * variables: {
1317 * input: // value for 'input'
1318 * },
1319 * });
1320 */
1321export function useBugAddCommentMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentMutation, BugAddCommentMutationVariables>) {
1322 const options = {...defaultOptions, ...baseOptions}
1323 return Apollo.useMutation<BugAddCommentMutation, BugAddCommentMutationVariables>(BugAddCommentDocument, options);
1324 }
1325export type BugAddCommentMutationHookResult = ReturnType<typeof useBugAddCommentMutation>;
1326export type BugAddCommentMutationResult = Apollo.MutationResult<BugAddCommentMutation>;
1327export type BugAddCommentMutationOptions = Apollo.BaseMutationOptions<BugAddCommentMutation, BugAddCommentMutationVariables>;
1328export const BugAddCommentAndCloseDocument = gql`
1329 mutation BugAddCommentAndClose($input: BugAddCommentAndCloseInput!) {
1330 bugAddCommentAndClose(input: $input) {
1331 bug {
1332 id
1333 }
1334 }
1335}
1336 `;
1337export type BugAddCommentAndCloseMutationFn = Apollo.MutationFunction<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>;
1338
1339/**
1340 * __useBugAddCommentAndCloseMutation__
1341 *
1342 * To run a mutation, you first call `useBugAddCommentAndCloseMutation` within a React component and pass it any options that fit your needs.
1343 * When your component renders, `useBugAddCommentAndCloseMutation` returns a tuple that includes:
1344 * - A mutate function that you can call at any time to execute the mutation
1345 * - An object with fields that represent the current status of the mutation's execution
1346 *
1347 * @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;
1348 *
1349 * @example
1350 * const [bugAddCommentAndCloseMutation, { data, loading, error }] = useBugAddCommentAndCloseMutation({
1351 * variables: {
1352 * input: // value for 'input'
1353 * },
1354 * });
1355 */
1356export function useBugAddCommentAndCloseMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>) {
1357 const options = {...defaultOptions, ...baseOptions}
1358 return Apollo.useMutation<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>(BugAddCommentAndCloseDocument, options);
1359 }
1360export type BugAddCommentAndCloseMutationHookResult = ReturnType<typeof useBugAddCommentAndCloseMutation>;
1361export type BugAddCommentAndCloseMutationResult = Apollo.MutationResult<BugAddCommentAndCloseMutation>;
1362export type BugAddCommentAndCloseMutationOptions = Apollo.BaseMutationOptions<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>;
1363export const BugAddCommentAndReopenDocument = gql`
1364 mutation BugAddCommentAndReopen($input: BugAddCommentAndReopenInput!) {
1365 bugAddCommentAndReopen(input: $input) {
1366 bug {
1367 id
1368 }
1369 }
1370}
1371 `;
1372export type BugAddCommentAndReopenMutationFn = Apollo.MutationFunction<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>;
1373
1374/**
1375 * __useBugAddCommentAndReopenMutation__
1376 *
1377 * To run a mutation, you first call `useBugAddCommentAndReopenMutation` within a React component and pass it any options that fit your needs.
1378 * When your component renders, `useBugAddCommentAndReopenMutation` returns a tuple that includes:
1379 * - A mutate function that you can call at any time to execute the mutation
1380 * - An object with fields that represent the current status of the mutation's execution
1381 *
1382 * @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;
1383 *
1384 * @example
1385 * const [bugAddCommentAndReopenMutation, { data, loading, error }] = useBugAddCommentAndReopenMutation({
1386 * variables: {
1387 * input: // value for 'input'
1388 * },
1389 * });
1390 */
1391export function useBugAddCommentAndReopenMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>) {
1392 const options = {...defaultOptions, ...baseOptions}
1393 return Apollo.useMutation<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>(BugAddCommentAndReopenDocument, options);
1394 }
1395export type BugAddCommentAndReopenMutationHookResult = ReturnType<typeof useBugAddCommentAndReopenMutation>;
1396export type BugAddCommentAndReopenMutationResult = Apollo.MutationResult<BugAddCommentAndReopenMutation>;
1397export type BugAddCommentAndReopenMutationOptions = Apollo.BaseMutationOptions<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>;
1398export const BugEditCommentDocument = gql`
1399 mutation BugEditComment($input: BugEditCommentInput!) {
1400 bugEditComment(input: $input) {
1401 bug {
1402 id
1403 }
1404 }
1405}
1406 `;
1407export type BugEditCommentMutationFn = Apollo.MutationFunction<BugEditCommentMutation, BugEditCommentMutationVariables>;
1408
1409/**
1410 * __useBugEditCommentMutation__
1411 *
1412 * To run a mutation, you first call `useBugEditCommentMutation` within a React component and pass it any options that fit your needs.
1413 * When your component renders, `useBugEditCommentMutation` returns a tuple that includes:
1414 * - A mutate function that you can call at any time to execute the mutation
1415 * - An object with fields that represent the current status of the mutation's execution
1416 *
1417 * @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;
1418 *
1419 * @example
1420 * const [bugEditCommentMutation, { data, loading, error }] = useBugEditCommentMutation({
1421 * variables: {
1422 * input: // value for 'input'
1423 * },
1424 * });
1425 */
1426export function useBugEditCommentMutation(baseOptions?: Apollo.MutationHookOptions<BugEditCommentMutation, BugEditCommentMutationVariables>) {
1427 const options = {...defaultOptions, ...baseOptions}
1428 return Apollo.useMutation<BugEditCommentMutation, BugEditCommentMutationVariables>(BugEditCommentDocument, options);
1429 }
1430export type BugEditCommentMutationHookResult = ReturnType<typeof useBugEditCommentMutation>;
1431export type BugEditCommentMutationResult = Apollo.MutationResult<BugEditCommentMutation>;
1432export type BugEditCommentMutationOptions = Apollo.BaseMutationOptions<BugEditCommentMutation, BugEditCommentMutationVariables>;
1433export const BugChangeLabelsDocument = gql`
1434 mutation BugChangeLabels($input: BugChangeLabelInput) {
1435 bugChangeLabels(input: $input) {
1436 bug {
1437 id
1438 labels {
1439 name
1440 color {
1441 R
1442 G
1443 B
1444 }
1445 }
1446 }
1447 }
1448}
1449 `;
1450export type BugChangeLabelsMutationFn = Apollo.MutationFunction<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>;
1451
1452/**
1453 * __useBugChangeLabelsMutation__
1454 *
1455 * To run a mutation, you first call `useBugChangeLabelsMutation` within a React component and pass it any options that fit your needs.
1456 * When your component renders, `useBugChangeLabelsMutation` returns a tuple that includes:
1457 * - A mutate function that you can call at any time to execute the mutation
1458 * - An object with fields that represent the current status of the mutation's execution
1459 *
1460 * @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;
1461 *
1462 * @example
1463 * const [bugChangeLabelsMutation, { data, loading, error }] = useBugChangeLabelsMutation({
1464 * variables: {
1465 * input: // value for 'input'
1466 * },
1467 * });
1468 */
1469export function useBugChangeLabelsMutation(baseOptions?: Apollo.MutationHookOptions<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>) {
1470 const options = {...defaultOptions, ...baseOptions}
1471 return Apollo.useMutation<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>(BugChangeLabelsDocument, options);
1472 }
1473export type BugChangeLabelsMutationHookResult = ReturnType<typeof useBugChangeLabelsMutation>;
1474export type BugChangeLabelsMutationResult = Apollo.MutationResult<BugChangeLabelsMutation>;
1475export type BugChangeLabelsMutationOptions = Apollo.BaseMutationOptions<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>;
1476export const BugStatusOpenDocument = gql`
1477 mutation BugStatusOpen($input: BugStatusOpenInput!) {
1478 bugStatusOpen(input: $input) {
1479 bug {
1480 id
1481 status
1482 }
1483 }
1484}
1485 `;
1486export type BugStatusOpenMutationFn = Apollo.MutationFunction<BugStatusOpenMutation, BugStatusOpenMutationVariables>;
1487
1488/**
1489 * __useBugStatusOpenMutation__
1490 *
1491 * To run a mutation, you first call `useBugStatusOpenMutation` within a React component and pass it any options that fit your needs.
1492 * When your component renders, `useBugStatusOpenMutation` returns a tuple that includes:
1493 * - A mutate function that you can call at any time to execute the mutation
1494 * - An object with fields that represent the current status of the mutation's execution
1495 *
1496 * @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;
1497 *
1498 * @example
1499 * const [bugStatusOpenMutation, { data, loading, error }] = useBugStatusOpenMutation({
1500 * variables: {
1501 * input: // value for 'input'
1502 * },
1503 * });
1504 */
1505export function useBugStatusOpenMutation(baseOptions?: Apollo.MutationHookOptions<BugStatusOpenMutation, BugStatusOpenMutationVariables>) {
1506 const options = {...defaultOptions, ...baseOptions}
1507 return Apollo.useMutation<BugStatusOpenMutation, BugStatusOpenMutationVariables>(BugStatusOpenDocument, options);
1508 }
1509export type BugStatusOpenMutationHookResult = ReturnType<typeof useBugStatusOpenMutation>;
1510export type BugStatusOpenMutationResult = Apollo.MutationResult<BugStatusOpenMutation>;
1511export type BugStatusOpenMutationOptions = Apollo.BaseMutationOptions<BugStatusOpenMutation, BugStatusOpenMutationVariables>;
1512export const BugStatusCloseDocument = gql`
1513 mutation BugStatusClose($input: BugStatusCloseInput!) {
1514 bugStatusClose(input: $input) {
1515 bug {
1516 id
1517 status
1518 }
1519 }
1520}
1521 `;
1522export type BugStatusCloseMutationFn = Apollo.MutationFunction<BugStatusCloseMutation, BugStatusCloseMutationVariables>;
1523
1524/**
1525 * __useBugStatusCloseMutation__
1526 *
1527 * To run a mutation, you first call `useBugStatusCloseMutation` within a React component and pass it any options that fit your needs.
1528 * When your component renders, `useBugStatusCloseMutation` returns a tuple that includes:
1529 * - A mutate function that you can call at any time to execute the mutation
1530 * - An object with fields that represent the current status of the mutation's execution
1531 *
1532 * @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;
1533 *
1534 * @example
1535 * const [bugStatusCloseMutation, { data, loading, error }] = useBugStatusCloseMutation({
1536 * variables: {
1537 * input: // value for 'input'
1538 * },
1539 * });
1540 */
1541export function useBugStatusCloseMutation(baseOptions?: Apollo.MutationHookOptions<BugStatusCloseMutation, BugStatusCloseMutationVariables>) {
1542 const options = {...defaultOptions, ...baseOptions}
1543 return Apollo.useMutation<BugStatusCloseMutation, BugStatusCloseMutationVariables>(BugStatusCloseDocument, options);
1544 }
1545export type BugStatusCloseMutationHookResult = ReturnType<typeof useBugStatusCloseMutation>;
1546export type BugStatusCloseMutationResult = Apollo.MutationResult<BugStatusCloseMutation>;
1547export type BugStatusCloseMutationOptions = Apollo.BaseMutationOptions<BugStatusCloseMutation, BugStatusCloseMutationVariables>;
1548export const BugSetTitleDocument = gql`
1549 mutation BugSetTitle($input: BugSetTitleInput!) {
1550 bugSetTitle(input: $input) {
1551 bug {
1552 id
1553 title
1554 }
1555 }
1556}
1557 `;
1558export type BugSetTitleMutationFn = Apollo.MutationFunction<BugSetTitleMutation, BugSetTitleMutationVariables>;
1559
1560/**
1561 * __useBugSetTitleMutation__
1562 *
1563 * To run a mutation, you first call `useBugSetTitleMutation` within a React component and pass it any options that fit your needs.
1564 * When your component renders, `useBugSetTitleMutation` returns a tuple that includes:
1565 * - A mutate function that you can call at any time to execute the mutation
1566 * - An object with fields that represent the current status of the mutation's execution
1567 *
1568 * @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;
1569 *
1570 * @example
1571 * const [bugSetTitleMutation, { data, loading, error }] = useBugSetTitleMutation({
1572 * variables: {
1573 * input: // value for 'input'
1574 * },
1575 * });
1576 */
1577export function useBugSetTitleMutation(baseOptions?: Apollo.MutationHookOptions<BugSetTitleMutation, BugSetTitleMutationVariables>) {
1578 const options = {...defaultOptions, ...baseOptions}
1579 return Apollo.useMutation<BugSetTitleMutation, BugSetTitleMutationVariables>(BugSetTitleDocument, options);
1580 }
1581export type BugSetTitleMutationHookResult = ReturnType<typeof useBugSetTitleMutation>;
1582export type BugSetTitleMutationResult = Apollo.MutationResult<BugSetTitleMutation>;
1583export type BugSetTitleMutationOptions = Apollo.BaseMutationOptions<BugSetTitleMutation, BugSetTitleMutationVariables>;
1584export const RepositoriesDocument = gql`
1585 query Repositories {
1586 repositories {
1587 nodes {
1588 name
1589 }
1590 totalCount
1591 }
1592}
1593 `;
1594
1595/**
1596 * __useRepositoriesQuery__
1597 *
1598 * To run a query within a React component, call `useRepositoriesQuery` and pass it any options that fit your needs.
1599 * When your component renders, `useRepositoriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
1600 * you can use to render your UI.
1601 *
1602 * @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;
1603 *
1604 * @example
1605 * const { data, loading, error } = useRepositoriesQuery({
1606 * variables: {
1607 * },
1608 * });
1609 */
1610export function useRepositoriesQuery(baseOptions?: Apollo.QueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1611 const options = {...defaultOptions, ...baseOptions}
1612 return Apollo.useQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1613 }
1614export function useRepositoriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1615 const options = {...defaultOptions, ...baseOptions}
1616 return Apollo.useLazyQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1617 }
1618// @ts-ignore
1619export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>): Apollo.UseSuspenseQueryResult<RepositoriesQuery, RepositoriesQueryVariables>;
1620export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>): Apollo.UseSuspenseQueryResult<RepositoriesQuery | undefined, RepositoriesQueryVariables>;
1621export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1622 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1623 return Apollo.useSuspenseQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1624 }
1625export type RepositoriesQueryHookResult = ReturnType<typeof useRepositoriesQuery>;
1626export type RepositoriesLazyQueryHookResult = ReturnType<typeof useRepositoriesLazyQuery>;
1627export type RepositoriesSuspenseQueryHookResult = ReturnType<typeof useRepositoriesSuspenseQuery>;
1628export type RepositoriesQueryResult = Apollo.QueryResult<RepositoriesQuery, RepositoriesQueryVariables>;
1629export const ServerConfigDocument = gql`
1630 query ServerConfig {
1631 serverConfig {
1632 authMode
1633 oauthProviders
1634 }
1635}
1636 `;
1637
1638/**
1639 * __useServerConfigQuery__
1640 *
1641 * To run a query within a React component, call `useServerConfigQuery` and pass it any options that fit your needs.
1642 * When your component renders, `useServerConfigQuery` returns an object from Apollo Client that contains loading, error, and data properties
1643 * you can use to render your UI.
1644 *
1645 * @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;
1646 *
1647 * @example
1648 * const { data, loading, error } = useServerConfigQuery({
1649 * variables: {
1650 * },
1651 * });
1652 */
1653export function useServerConfigQuery(baseOptions?: Apollo.QueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1654 const options = {...defaultOptions, ...baseOptions}
1655 return Apollo.useQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1656 }
1657export function useServerConfigLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1658 const options = {...defaultOptions, ...baseOptions}
1659 return Apollo.useLazyQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1660 }
1661// @ts-ignore
1662export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>): Apollo.UseSuspenseQueryResult<ServerConfigQuery, ServerConfigQueryVariables>;
1663export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>): Apollo.UseSuspenseQueryResult<ServerConfigQuery | undefined, ServerConfigQueryVariables>;
1664export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1665 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1666 return Apollo.useSuspenseQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1667 }
1668export type ServerConfigQueryHookResult = ReturnType<typeof useServerConfigQuery>;
1669export type ServerConfigLazyQueryHookResult = ReturnType<typeof useServerConfigLazyQuery>;
1670export type ServerConfigSuspenseQueryHookResult = ReturnType<typeof useServerConfigSuspenseQuery>;
1671export type ServerConfigQueryResult = Apollo.QueryResult<ServerConfigQuery, ServerConfigQueryVariables>;
1672export const UserProfileDocument = gql`
1673 query UserProfile($ref: String, $prefix: String!, $openQuery: String!, $closedQuery: String!, $listQuery: String!, $after: String) {
1674 repository(ref: $ref) {
1675 identity(prefix: $prefix) {
1676 id
1677 humanId
1678 name
1679 email
1680 login
1681 displayName
1682 avatarUrl
1683 isProtected
1684 }
1685 openCount: allBugs(query: $openQuery, first: 1) {
1686 totalCount
1687 }
1688 closedCount: allBugs(query: $closedQuery, first: 1) {
1689 totalCount
1690 }
1691 bugs: allBugs(query: $listQuery, first: 25, after: $after) {
1692 totalCount
1693 pageInfo {
1694 hasNextPage
1695 endCursor
1696 }
1697 nodes {
1698 id
1699 humanId
1700 status
1701 title
1702 labels {
1703 name
1704 color {
1705 R
1706 G
1707 B
1708 }
1709 }
1710 createdAt
1711 comments {
1712 totalCount
1713 }
1714 }
1715 }
1716 }
1717}
1718 `;
1719
1720/**
1721 * __useUserProfileQuery__
1722 *
1723 * To run a query within a React component, call `useUserProfileQuery` and pass it any options that fit your needs.
1724 * When your component renders, `useUserProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
1725 * you can use to render your UI.
1726 *
1727 * @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;
1728 *
1729 * @example
1730 * const { data, loading, error } = useUserProfileQuery({
1731 * variables: {
1732 * ref: // value for 'ref'
1733 * prefix: // value for 'prefix'
1734 * openQuery: // value for 'openQuery'
1735 * closedQuery: // value for 'closedQuery'
1736 * listQuery: // value for 'listQuery'
1737 * after: // value for 'after'
1738 * },
1739 * });
1740 */
1741export function useUserProfileQuery(baseOptions: Apollo.QueryHookOptions<UserProfileQuery, UserProfileQueryVariables> & ({ variables: UserProfileQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
1742 const options = {...defaultOptions, ...baseOptions}
1743 return Apollo.useQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1744 }
1745export function useUserProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {
1746 const options = {...defaultOptions, ...baseOptions}
1747 return Apollo.useLazyQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1748 }
1749// @ts-ignore
1750export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>): Apollo.UseSuspenseQueryResult<UserProfileQuery, UserProfileQueryVariables>;
1751export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>): Apollo.UseSuspenseQueryResult<UserProfileQuery | undefined, UserProfileQueryVariables>;
1752export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {
1753 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1754 return Apollo.useSuspenseQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1755 }
1756export type UserProfileQueryHookResult = ReturnType<typeof useUserProfileQuery>;
1757export type UserProfileLazyQueryHookResult = ReturnType<typeof useUserProfileLazyQuery>;
1758export type UserProfileSuspenseQueryHookResult = ReturnType<typeof useUserProfileSuspenseQuery>;
1759export type UserProfileQueryResult = Apollo.QueryResult<UserProfileQuery, UserProfileQueryVariables>;
1760export const ValidLabelsDocument = gql`
1761 query ValidLabels($ref: String) {
1762 repository(ref: $ref) {
1763 validLabels {
1764 nodes {
1765 name
1766 color {
1767 R
1768 G
1769 B
1770 }
1771 }
1772 }
1773 }
1774}
1775 `;
1776
1777/**
1778 * __useValidLabelsQuery__
1779 *
1780 * To run a query within a React component, call `useValidLabelsQuery` and pass it any options that fit your needs.
1781 * When your component renders, `useValidLabelsQuery` returns an object from Apollo Client that contains loading, error, and data properties
1782 * you can use to render your UI.
1783 *
1784 * @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;
1785 *
1786 * @example
1787 * const { data, loading, error } = useValidLabelsQuery({
1788 * variables: {
1789 * ref: // value for 'ref'
1790 * },
1791 * });
1792 */
1793export function useValidLabelsQuery(baseOptions?: Apollo.QueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1794 const options = {...defaultOptions, ...baseOptions}
1795 return Apollo.useQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1796 }
1797export function useValidLabelsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1798 const options = {...defaultOptions, ...baseOptions}
1799 return Apollo.useLazyQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1800 }
1801// @ts-ignore
1802export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>): Apollo.UseSuspenseQueryResult<ValidLabelsQuery, ValidLabelsQueryVariables>;
1803export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>): Apollo.UseSuspenseQueryResult<ValidLabelsQuery | undefined, ValidLabelsQueryVariables>;
1804export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1805 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1806 return Apollo.useSuspenseQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1807 }
1808export type ValidLabelsQueryHookResult = ReturnType<typeof useValidLabelsQuery>;
1809export type ValidLabelsLazyQueryHookResult = ReturnType<typeof useValidLabelsLazyQuery>;
1810export type ValidLabelsSuspenseQueryHookResult = ReturnType<typeof useValidLabelsSuspenseQuery>;
1811export type ValidLabelsQueryResult = Apollo.QueryResult<ValidLabelsQuery, ValidLabelsQueryVariables>;