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 */
765 name?: Maybe<Scalars['String']['output']>;
766 /**
767 * URL-friendly slug for this repository. Named repos use their name;
768 * the default (unnamed) repo derives the slug from the directory basename.
769 */
770 slug: Scalars['String']['output'];
771 /** The identity created or selected by the user as its own */
772 userIdentity?: Maybe<Identity>;
773 /** List of valid labels. */
774 validLabels: LabelConnection;
775};
776
777
778export type RepositoryAllBugsArgs = {
779 after?: InputMaybe<Scalars['String']['input']>;
780 before?: InputMaybe<Scalars['String']['input']>;
781 first?: InputMaybe<Scalars['Int']['input']>;
782 last?: InputMaybe<Scalars['Int']['input']>;
783 query?: InputMaybe<Scalars['String']['input']>;
784};
785
786
787export type RepositoryAllIdentitiesArgs = {
788 after?: InputMaybe<Scalars['String']['input']>;
789 before?: InputMaybe<Scalars['String']['input']>;
790 first?: InputMaybe<Scalars['Int']['input']>;
791 last?: InputMaybe<Scalars['Int']['input']>;
792};
793
794
795export type RepositoryBugArgs = {
796 prefix: Scalars['String']['input'];
797};
798
799
800export type RepositoryIdentityArgs = {
801 prefix: Scalars['String']['input'];
802};
803
804
805export type RepositoryValidLabelsArgs = {
806 after?: InputMaybe<Scalars['String']['input']>;
807 before?: InputMaybe<Scalars['String']['input']>;
808 first?: InputMaybe<Scalars['Int']['input']>;
809 last?: InputMaybe<Scalars['Int']['input']>;
810};
811
812export type RepositoryConnection = {
813 __typename?: 'RepositoryConnection';
814 edges: Array<RepositoryEdge>;
815 nodes: Array<Repository>;
816 pageInfo: PageInfo;
817 totalCount: Scalars['Int']['output'];
818};
819
820export type RepositoryEdge = {
821 __typename?: 'RepositoryEdge';
822 cursor: Scalars['String']['output'];
823 node: Repository;
824};
825
826/** Server-wide configuration, independent of any repository. */
827export type ServerConfig = {
828 __typename?: 'ServerConfig';
829 /**
830 * Authentication mode: 'local' (single user from git config),
831 * 'oauth' (multi-user via external providers), or 'readonly'.
832 */
833 authMode: Scalars['String']['output'];
834 /**
835 * Names of the OAuth providers enabled on this server, e.g. ['github'].
836 * Empty when authMode is not 'oauth'.
837 */
838 oauthProviders: Array<Scalars['String']['output']>;
839};
840
841export enum Status {
842 Closed = 'CLOSED',
843 Open = 'OPEN'
844}
845
846export type Subscription = {
847 __typename?: 'Subscription';
848 /** 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. */
849 allEvents: EntityEvent;
850 /** 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. */
851 bugEvents: BugEvent;
852 /** 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. */
853 identityEvents: IdentityEvent;
854};
855
856
857export type SubscriptionAllEventsArgs = {
858 repoRef?: InputMaybe<Scalars['String']['input']>;
859 typename?: InputMaybe<Scalars['String']['input']>;
860};
861
862
863export type SubscriptionBugEventsArgs = {
864 repoRef?: InputMaybe<Scalars['String']['input']>;
865};
866
867
868export type SubscriptionIdentityEventsArgs = {
869 repoRef?: InputMaybe<Scalars['String']['input']>;
870};
871
872export type AllIdentitiesQueryVariables = Exact<{
873 ref?: InputMaybe<Scalars['String']['input']>;
874}>;
875
876
877export 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 };
878
879export type BugDetailQueryVariables = Exact<{
880 ref?: InputMaybe<Scalars['String']['input']>;
881 prefix: Scalars['String']['input'];
882}>;
883
884
885export 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 };
886
887export type BugListQueryVariables = Exact<{
888 ref?: InputMaybe<Scalars['String']['input']>;
889 query?: InputMaybe<Scalars['String']['input']>;
890 first?: InputMaybe<Scalars['Int']['input']>;
891 after?: InputMaybe<Scalars['String']['input']>;
892}>;
893
894
895export 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 };
896
897export type BugCreateMutationVariables = Exact<{
898 input: BugCreateInput;
899}>;
900
901
902export type BugCreateMutation = { __typename?: 'Mutation', bugCreate: { __typename?: 'BugCreatePayload', bug: { __typename?: 'Bug', id: string, humanId: string } } };
903
904export type BugAddCommentMutationVariables = Exact<{
905 input: BugAddCommentInput;
906}>;
907
908
909export type BugAddCommentMutation = { __typename?: 'Mutation', bugAddComment: { __typename?: 'BugAddCommentPayload', bug: { __typename?: 'Bug', id: string } } };
910
911export type BugAddCommentAndCloseMutationVariables = Exact<{
912 input: BugAddCommentAndCloseInput;
913}>;
914
915
916export type BugAddCommentAndCloseMutation = { __typename?: 'Mutation', bugAddCommentAndClose: { __typename?: 'BugAddCommentAndClosePayload', bug: { __typename?: 'Bug', id: string } } };
917
918export type BugAddCommentAndReopenMutationVariables = Exact<{
919 input: BugAddCommentAndReopenInput;
920}>;
921
922
923export type BugAddCommentAndReopenMutation = { __typename?: 'Mutation', bugAddCommentAndReopen: { __typename?: 'BugAddCommentAndReopenPayload', bug: { __typename?: 'Bug', id: string } } };
924
925export type BugEditCommentMutationVariables = Exact<{
926 input: BugEditCommentInput;
927}>;
928
929
930export type BugEditCommentMutation = { __typename?: 'Mutation', bugEditComment: { __typename?: 'BugEditCommentPayload', bug: { __typename?: 'Bug', id: string } } };
931
932export type BugChangeLabelsMutationVariables = Exact<{
933 input?: InputMaybe<BugChangeLabelInput>;
934}>;
935
936
937export 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 } }> } } };
938
939export type BugStatusOpenMutationVariables = Exact<{
940 input: BugStatusOpenInput;
941}>;
942
943
944export type BugStatusOpenMutation = { __typename?: 'Mutation', bugStatusOpen: { __typename?: 'BugStatusOpenPayload', bug: { __typename?: 'Bug', id: string, status: Status } } };
945
946export type BugStatusCloseMutationVariables = Exact<{
947 input: BugStatusCloseInput;
948}>;
949
950
951export type BugStatusCloseMutation = { __typename?: 'Mutation', bugStatusClose: { __typename?: 'BugStatusClosePayload', bug: { __typename?: 'Bug', id: string, status: Status } } };
952
953export type BugSetTitleMutationVariables = Exact<{
954 input: BugSetTitleInput;
955}>;
956
957
958export type BugSetTitleMutation = { __typename?: 'Mutation', bugSetTitle: { __typename?: 'BugSetTitlePayload', bug: { __typename?: 'Bug', id: string, title: string } } };
959
960export type RepositoriesQueryVariables = Exact<{ [key: string]: never; }>;
961
962
963export type RepositoriesQuery = { __typename?: 'Query', repositories: { __typename?: 'RepositoryConnection', totalCount: number, nodes: Array<{ __typename?: 'Repository', name?: string | null, slug: string }> } };
964
965export type ServerConfigQueryVariables = Exact<{ [key: string]: never; }>;
966
967
968export type ServerConfigQuery = { __typename?: 'Query', serverConfig: { __typename?: 'ServerConfig', authMode: string, oauthProviders: Array<string> } };
969
970export type UserProfileQueryVariables = Exact<{
971 ref?: InputMaybe<Scalars['String']['input']>;
972 prefix: Scalars['String']['input'];
973 openQuery: Scalars['String']['input'];
974 closedQuery: Scalars['String']['input'];
975 listQuery: Scalars['String']['input'];
976 after?: InputMaybe<Scalars['String']['input']>;
977}>;
978
979
980export 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 };
981
982export type ValidLabelsQueryVariables = Exact<{
983 ref?: InputMaybe<Scalars['String']['input']>;
984}>;
985
986
987export 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 };
988
989
990export const AllIdentitiesDocument = gql`
991 query AllIdentities($ref: String) {
992 repository(ref: $ref) {
993 allIdentities(first: 1000) {
994 nodes {
995 id
996 humanId
997 name
998 email
999 login
1000 displayName
1001 avatarUrl
1002 }
1003 }
1004 }
1005}
1006 `;
1007
1008/**
1009 * __useAllIdentitiesQuery__
1010 *
1011 * To run a query within a React component, call `useAllIdentitiesQuery` and pass it any options that fit your needs.
1012 * When your component renders, `useAllIdentitiesQuery` returns an object from Apollo Client that contains loading, error, and data properties
1013 * you can use to render your UI.
1014 *
1015 * @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;
1016 *
1017 * @example
1018 * const { data, loading, error } = useAllIdentitiesQuery({
1019 * variables: {
1020 * ref: // value for 'ref'
1021 * },
1022 * });
1023 */
1024export function useAllIdentitiesQuery(baseOptions?: Apollo.QueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
1025 const options = {...defaultOptions, ...baseOptions}
1026 return Apollo.useQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
1027 }
1028export function useAllIdentitiesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
1029 const options = {...defaultOptions, ...baseOptions}
1030 return Apollo.useLazyQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
1031 }
1032// @ts-ignore
1033export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>): Apollo.UseSuspenseQueryResult<AllIdentitiesQuery, AllIdentitiesQueryVariables>;
1034export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>): Apollo.UseSuspenseQueryResult<AllIdentitiesQuery | undefined, AllIdentitiesQueryVariables>;
1035export function useAllIdentitiesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AllIdentitiesQuery, AllIdentitiesQueryVariables>) {
1036 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1037 return Apollo.useSuspenseQuery<AllIdentitiesQuery, AllIdentitiesQueryVariables>(AllIdentitiesDocument, options);
1038 }
1039export type AllIdentitiesQueryHookResult = ReturnType<typeof useAllIdentitiesQuery>;
1040export type AllIdentitiesLazyQueryHookResult = ReturnType<typeof useAllIdentitiesLazyQuery>;
1041export type AllIdentitiesSuspenseQueryHookResult = ReturnType<typeof useAllIdentitiesSuspenseQuery>;
1042export type AllIdentitiesQueryResult = Apollo.QueryResult<AllIdentitiesQuery, AllIdentitiesQueryVariables>;
1043export const BugDetailDocument = gql`
1044 query BugDetail($ref: String, $prefix: String!) {
1045 repository(ref: $ref) {
1046 bug(prefix: $prefix) {
1047 id
1048 humanId
1049 status
1050 title
1051 labels {
1052 name
1053 color {
1054 R
1055 G
1056 B
1057 }
1058 }
1059 author {
1060 id
1061 humanId
1062 displayName
1063 avatarUrl
1064 }
1065 createdAt
1066 lastEdit
1067 participants(first: 20) {
1068 nodes {
1069 id
1070 humanId
1071 displayName
1072 avatarUrl
1073 }
1074 }
1075 timeline(first: 250) {
1076 nodes {
1077 __typename
1078 id
1079 ... on BugCreateTimelineItem {
1080 author {
1081 id
1082 humanId
1083 displayName
1084 avatarUrl
1085 }
1086 message
1087 createdAt
1088 lastEdit
1089 edited
1090 }
1091 ... on BugAddCommentTimelineItem {
1092 author {
1093 id
1094 humanId
1095 displayName
1096 avatarUrl
1097 }
1098 message
1099 createdAt
1100 lastEdit
1101 edited
1102 }
1103 ... on BugLabelChangeTimelineItem {
1104 author {
1105 humanId
1106 displayName
1107 }
1108 date
1109 added {
1110 name
1111 color {
1112 R
1113 G
1114 B
1115 }
1116 }
1117 removed {
1118 name
1119 color {
1120 R
1121 G
1122 B
1123 }
1124 }
1125 }
1126 ... on BugSetStatusTimelineItem {
1127 author {
1128 humanId
1129 displayName
1130 }
1131 date
1132 status
1133 }
1134 ... on BugSetTitleTimelineItem {
1135 author {
1136 humanId
1137 displayName
1138 }
1139 date
1140 title
1141 was
1142 }
1143 }
1144 }
1145 }
1146 }
1147}
1148 `;
1149
1150/**
1151 * __useBugDetailQuery__
1152 *
1153 * To run a query within a React component, call `useBugDetailQuery` and pass it any options that fit your needs.
1154 * When your component renders, `useBugDetailQuery` returns an object from Apollo Client that contains loading, error, and data properties
1155 * you can use to render your UI.
1156 *
1157 * @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;
1158 *
1159 * @example
1160 * const { data, loading, error } = useBugDetailQuery({
1161 * variables: {
1162 * ref: // value for 'ref'
1163 * prefix: // value for 'prefix'
1164 * },
1165 * });
1166 */
1167export function useBugDetailQuery(baseOptions: Apollo.QueryHookOptions<BugDetailQuery, BugDetailQueryVariables> & ({ variables: BugDetailQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
1168 const options = {...defaultOptions, ...baseOptions}
1169 return Apollo.useQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1170 }
1171export function useBugDetailLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>) {
1172 const options = {...defaultOptions, ...baseOptions}
1173 return Apollo.useLazyQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1174 }
1175// @ts-ignore
1176export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>): Apollo.UseSuspenseQueryResult<BugDetailQuery, BugDetailQueryVariables>;
1177export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>): Apollo.UseSuspenseQueryResult<BugDetailQuery | undefined, BugDetailQueryVariables>;
1178export function useBugDetailSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugDetailQuery, BugDetailQueryVariables>) {
1179 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1180 return Apollo.useSuspenseQuery<BugDetailQuery, BugDetailQueryVariables>(BugDetailDocument, options);
1181 }
1182export type BugDetailQueryHookResult = ReturnType<typeof useBugDetailQuery>;
1183export type BugDetailLazyQueryHookResult = ReturnType<typeof useBugDetailLazyQuery>;
1184export type BugDetailSuspenseQueryHookResult = ReturnType<typeof useBugDetailSuspenseQuery>;
1185export type BugDetailQueryResult = Apollo.QueryResult<BugDetailQuery, BugDetailQueryVariables>;
1186export const BugListDocument = gql`
1187 query BugList($ref: String, $query: String, $first: Int, $after: String) {
1188 repository(ref: $ref) {
1189 allBugs(query: $query, first: $first, after: $after) {
1190 totalCount
1191 pageInfo {
1192 hasNextPage
1193 endCursor
1194 }
1195 nodes {
1196 id
1197 humanId
1198 status
1199 title
1200 labels {
1201 name
1202 color {
1203 R
1204 G
1205 B
1206 }
1207 }
1208 author {
1209 id
1210 humanId
1211 displayName
1212 avatarUrl
1213 }
1214 createdAt
1215 comments {
1216 totalCount
1217 }
1218 }
1219 }
1220 }
1221}
1222 `;
1223
1224/**
1225 * __useBugListQuery__
1226 *
1227 * To run a query within a React component, call `useBugListQuery` and pass it any options that fit your needs.
1228 * When your component renders, `useBugListQuery` returns an object from Apollo Client that contains loading, error, and data properties
1229 * you can use to render your UI.
1230 *
1231 * @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;
1232 *
1233 * @example
1234 * const { data, loading, error } = useBugListQuery({
1235 * variables: {
1236 * ref: // value for 'ref'
1237 * query: // value for 'query'
1238 * first: // value for 'first'
1239 * after: // value for 'after'
1240 * },
1241 * });
1242 */
1243export function useBugListQuery(baseOptions?: Apollo.QueryHookOptions<BugListQuery, BugListQueryVariables>) {
1244 const options = {...defaultOptions, ...baseOptions}
1245 return Apollo.useQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1246 }
1247export function useBugListLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BugListQuery, BugListQueryVariables>) {
1248 const options = {...defaultOptions, ...baseOptions}
1249 return Apollo.useLazyQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1250 }
1251// @ts-ignore
1252export function useBugListSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>): Apollo.UseSuspenseQueryResult<BugListQuery, BugListQueryVariables>;
1253export function useBugListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>): Apollo.UseSuspenseQueryResult<BugListQuery | undefined, BugListQueryVariables>;
1254export function useBugListSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BugListQuery, BugListQueryVariables>) {
1255 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1256 return Apollo.useSuspenseQuery<BugListQuery, BugListQueryVariables>(BugListDocument, options);
1257 }
1258export type BugListQueryHookResult = ReturnType<typeof useBugListQuery>;
1259export type BugListLazyQueryHookResult = ReturnType<typeof useBugListLazyQuery>;
1260export type BugListSuspenseQueryHookResult = ReturnType<typeof useBugListSuspenseQuery>;
1261export type BugListQueryResult = Apollo.QueryResult<BugListQuery, BugListQueryVariables>;
1262export const BugCreateDocument = gql`
1263 mutation BugCreate($input: BugCreateInput!) {
1264 bugCreate(input: $input) {
1265 bug {
1266 id
1267 humanId
1268 }
1269 }
1270}
1271 `;
1272export type BugCreateMutationFn = Apollo.MutationFunction<BugCreateMutation, BugCreateMutationVariables>;
1273
1274/**
1275 * __useBugCreateMutation__
1276 *
1277 * To run a mutation, you first call `useBugCreateMutation` within a React component and pass it any options that fit your needs.
1278 * When your component renders, `useBugCreateMutation` returns a tuple that includes:
1279 * - A mutate function that you can call at any time to execute the mutation
1280 * - An object with fields that represent the current status of the mutation's execution
1281 *
1282 * @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;
1283 *
1284 * @example
1285 * const [bugCreateMutation, { data, loading, error }] = useBugCreateMutation({
1286 * variables: {
1287 * input: // value for 'input'
1288 * },
1289 * });
1290 */
1291export function useBugCreateMutation(baseOptions?: Apollo.MutationHookOptions<BugCreateMutation, BugCreateMutationVariables>) {
1292 const options = {...defaultOptions, ...baseOptions}
1293 return Apollo.useMutation<BugCreateMutation, BugCreateMutationVariables>(BugCreateDocument, options);
1294 }
1295export type BugCreateMutationHookResult = ReturnType<typeof useBugCreateMutation>;
1296export type BugCreateMutationResult = Apollo.MutationResult<BugCreateMutation>;
1297export type BugCreateMutationOptions = Apollo.BaseMutationOptions<BugCreateMutation, BugCreateMutationVariables>;
1298export const BugAddCommentDocument = gql`
1299 mutation BugAddComment($input: BugAddCommentInput!) {
1300 bugAddComment(input: $input) {
1301 bug {
1302 id
1303 }
1304 }
1305}
1306 `;
1307export type BugAddCommentMutationFn = Apollo.MutationFunction<BugAddCommentMutation, BugAddCommentMutationVariables>;
1308
1309/**
1310 * __useBugAddCommentMutation__
1311 *
1312 * To run a mutation, you first call `useBugAddCommentMutation` within a React component and pass it any options that fit your needs.
1313 * When your component renders, `useBugAddCommentMutation` returns a tuple that includes:
1314 * - A mutate function that you can call at any time to execute the mutation
1315 * - An object with fields that represent the current status of the mutation's execution
1316 *
1317 * @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;
1318 *
1319 * @example
1320 * const [bugAddCommentMutation, { data, loading, error }] = useBugAddCommentMutation({
1321 * variables: {
1322 * input: // value for 'input'
1323 * },
1324 * });
1325 */
1326export function useBugAddCommentMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentMutation, BugAddCommentMutationVariables>) {
1327 const options = {...defaultOptions, ...baseOptions}
1328 return Apollo.useMutation<BugAddCommentMutation, BugAddCommentMutationVariables>(BugAddCommentDocument, options);
1329 }
1330export type BugAddCommentMutationHookResult = ReturnType<typeof useBugAddCommentMutation>;
1331export type BugAddCommentMutationResult = Apollo.MutationResult<BugAddCommentMutation>;
1332export type BugAddCommentMutationOptions = Apollo.BaseMutationOptions<BugAddCommentMutation, BugAddCommentMutationVariables>;
1333export const BugAddCommentAndCloseDocument = gql`
1334 mutation BugAddCommentAndClose($input: BugAddCommentAndCloseInput!) {
1335 bugAddCommentAndClose(input: $input) {
1336 bug {
1337 id
1338 }
1339 }
1340}
1341 `;
1342export type BugAddCommentAndCloseMutationFn = Apollo.MutationFunction<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>;
1343
1344/**
1345 * __useBugAddCommentAndCloseMutation__
1346 *
1347 * To run a mutation, you first call `useBugAddCommentAndCloseMutation` within a React component and pass it any options that fit your needs.
1348 * When your component renders, `useBugAddCommentAndCloseMutation` returns a tuple that includes:
1349 * - A mutate function that you can call at any time to execute the mutation
1350 * - An object with fields that represent the current status of the mutation's execution
1351 *
1352 * @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;
1353 *
1354 * @example
1355 * const [bugAddCommentAndCloseMutation, { data, loading, error }] = useBugAddCommentAndCloseMutation({
1356 * variables: {
1357 * input: // value for 'input'
1358 * },
1359 * });
1360 */
1361export function useBugAddCommentAndCloseMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>) {
1362 const options = {...defaultOptions, ...baseOptions}
1363 return Apollo.useMutation<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>(BugAddCommentAndCloseDocument, options);
1364 }
1365export type BugAddCommentAndCloseMutationHookResult = ReturnType<typeof useBugAddCommentAndCloseMutation>;
1366export type BugAddCommentAndCloseMutationResult = Apollo.MutationResult<BugAddCommentAndCloseMutation>;
1367export type BugAddCommentAndCloseMutationOptions = Apollo.BaseMutationOptions<BugAddCommentAndCloseMutation, BugAddCommentAndCloseMutationVariables>;
1368export const BugAddCommentAndReopenDocument = gql`
1369 mutation BugAddCommentAndReopen($input: BugAddCommentAndReopenInput!) {
1370 bugAddCommentAndReopen(input: $input) {
1371 bug {
1372 id
1373 }
1374 }
1375}
1376 `;
1377export type BugAddCommentAndReopenMutationFn = Apollo.MutationFunction<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>;
1378
1379/**
1380 * __useBugAddCommentAndReopenMutation__
1381 *
1382 * To run a mutation, you first call `useBugAddCommentAndReopenMutation` within a React component and pass it any options that fit your needs.
1383 * When your component renders, `useBugAddCommentAndReopenMutation` returns a tuple that includes:
1384 * - A mutate function that you can call at any time to execute the mutation
1385 * - An object with fields that represent the current status of the mutation's execution
1386 *
1387 * @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;
1388 *
1389 * @example
1390 * const [bugAddCommentAndReopenMutation, { data, loading, error }] = useBugAddCommentAndReopenMutation({
1391 * variables: {
1392 * input: // value for 'input'
1393 * },
1394 * });
1395 */
1396export function useBugAddCommentAndReopenMutation(baseOptions?: Apollo.MutationHookOptions<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>) {
1397 const options = {...defaultOptions, ...baseOptions}
1398 return Apollo.useMutation<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>(BugAddCommentAndReopenDocument, options);
1399 }
1400export type BugAddCommentAndReopenMutationHookResult = ReturnType<typeof useBugAddCommentAndReopenMutation>;
1401export type BugAddCommentAndReopenMutationResult = Apollo.MutationResult<BugAddCommentAndReopenMutation>;
1402export type BugAddCommentAndReopenMutationOptions = Apollo.BaseMutationOptions<BugAddCommentAndReopenMutation, BugAddCommentAndReopenMutationVariables>;
1403export const BugEditCommentDocument = gql`
1404 mutation BugEditComment($input: BugEditCommentInput!) {
1405 bugEditComment(input: $input) {
1406 bug {
1407 id
1408 }
1409 }
1410}
1411 `;
1412export type BugEditCommentMutationFn = Apollo.MutationFunction<BugEditCommentMutation, BugEditCommentMutationVariables>;
1413
1414/**
1415 * __useBugEditCommentMutation__
1416 *
1417 * To run a mutation, you first call `useBugEditCommentMutation` within a React component and pass it any options that fit your needs.
1418 * When your component renders, `useBugEditCommentMutation` returns a tuple that includes:
1419 * - A mutate function that you can call at any time to execute the mutation
1420 * - An object with fields that represent the current status of the mutation's execution
1421 *
1422 * @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;
1423 *
1424 * @example
1425 * const [bugEditCommentMutation, { data, loading, error }] = useBugEditCommentMutation({
1426 * variables: {
1427 * input: // value for 'input'
1428 * },
1429 * });
1430 */
1431export function useBugEditCommentMutation(baseOptions?: Apollo.MutationHookOptions<BugEditCommentMutation, BugEditCommentMutationVariables>) {
1432 const options = {...defaultOptions, ...baseOptions}
1433 return Apollo.useMutation<BugEditCommentMutation, BugEditCommentMutationVariables>(BugEditCommentDocument, options);
1434 }
1435export type BugEditCommentMutationHookResult = ReturnType<typeof useBugEditCommentMutation>;
1436export type BugEditCommentMutationResult = Apollo.MutationResult<BugEditCommentMutation>;
1437export type BugEditCommentMutationOptions = Apollo.BaseMutationOptions<BugEditCommentMutation, BugEditCommentMutationVariables>;
1438export const BugChangeLabelsDocument = gql`
1439 mutation BugChangeLabels($input: BugChangeLabelInput) {
1440 bugChangeLabels(input: $input) {
1441 bug {
1442 id
1443 labels {
1444 name
1445 color {
1446 R
1447 G
1448 B
1449 }
1450 }
1451 }
1452 }
1453}
1454 `;
1455export type BugChangeLabelsMutationFn = Apollo.MutationFunction<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>;
1456
1457/**
1458 * __useBugChangeLabelsMutation__
1459 *
1460 * To run a mutation, you first call `useBugChangeLabelsMutation` within a React component and pass it any options that fit your needs.
1461 * When your component renders, `useBugChangeLabelsMutation` returns a tuple that includes:
1462 * - A mutate function that you can call at any time to execute the mutation
1463 * - An object with fields that represent the current status of the mutation's execution
1464 *
1465 * @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;
1466 *
1467 * @example
1468 * const [bugChangeLabelsMutation, { data, loading, error }] = useBugChangeLabelsMutation({
1469 * variables: {
1470 * input: // value for 'input'
1471 * },
1472 * });
1473 */
1474export function useBugChangeLabelsMutation(baseOptions?: Apollo.MutationHookOptions<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>) {
1475 const options = {...defaultOptions, ...baseOptions}
1476 return Apollo.useMutation<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>(BugChangeLabelsDocument, options);
1477 }
1478export type BugChangeLabelsMutationHookResult = ReturnType<typeof useBugChangeLabelsMutation>;
1479export type BugChangeLabelsMutationResult = Apollo.MutationResult<BugChangeLabelsMutation>;
1480export type BugChangeLabelsMutationOptions = Apollo.BaseMutationOptions<BugChangeLabelsMutation, BugChangeLabelsMutationVariables>;
1481export const BugStatusOpenDocument = gql`
1482 mutation BugStatusOpen($input: BugStatusOpenInput!) {
1483 bugStatusOpen(input: $input) {
1484 bug {
1485 id
1486 status
1487 }
1488 }
1489}
1490 `;
1491export type BugStatusOpenMutationFn = Apollo.MutationFunction<BugStatusOpenMutation, BugStatusOpenMutationVariables>;
1492
1493/**
1494 * __useBugStatusOpenMutation__
1495 *
1496 * To run a mutation, you first call `useBugStatusOpenMutation` within a React component and pass it any options that fit your needs.
1497 * When your component renders, `useBugStatusOpenMutation` returns a tuple that includes:
1498 * - A mutate function that you can call at any time to execute the mutation
1499 * - An object with fields that represent the current status of the mutation's execution
1500 *
1501 * @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;
1502 *
1503 * @example
1504 * const [bugStatusOpenMutation, { data, loading, error }] = useBugStatusOpenMutation({
1505 * variables: {
1506 * input: // value for 'input'
1507 * },
1508 * });
1509 */
1510export function useBugStatusOpenMutation(baseOptions?: Apollo.MutationHookOptions<BugStatusOpenMutation, BugStatusOpenMutationVariables>) {
1511 const options = {...defaultOptions, ...baseOptions}
1512 return Apollo.useMutation<BugStatusOpenMutation, BugStatusOpenMutationVariables>(BugStatusOpenDocument, options);
1513 }
1514export type BugStatusOpenMutationHookResult = ReturnType<typeof useBugStatusOpenMutation>;
1515export type BugStatusOpenMutationResult = Apollo.MutationResult<BugStatusOpenMutation>;
1516export type BugStatusOpenMutationOptions = Apollo.BaseMutationOptions<BugStatusOpenMutation, BugStatusOpenMutationVariables>;
1517export const BugStatusCloseDocument = gql`
1518 mutation BugStatusClose($input: BugStatusCloseInput!) {
1519 bugStatusClose(input: $input) {
1520 bug {
1521 id
1522 status
1523 }
1524 }
1525}
1526 `;
1527export type BugStatusCloseMutationFn = Apollo.MutationFunction<BugStatusCloseMutation, BugStatusCloseMutationVariables>;
1528
1529/**
1530 * __useBugStatusCloseMutation__
1531 *
1532 * To run a mutation, you first call `useBugStatusCloseMutation` within a React component and pass it any options that fit your needs.
1533 * When your component renders, `useBugStatusCloseMutation` returns a tuple that includes:
1534 * - A mutate function that you can call at any time to execute the mutation
1535 * - An object with fields that represent the current status of the mutation's execution
1536 *
1537 * @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;
1538 *
1539 * @example
1540 * const [bugStatusCloseMutation, { data, loading, error }] = useBugStatusCloseMutation({
1541 * variables: {
1542 * input: // value for 'input'
1543 * },
1544 * });
1545 */
1546export function useBugStatusCloseMutation(baseOptions?: Apollo.MutationHookOptions<BugStatusCloseMutation, BugStatusCloseMutationVariables>) {
1547 const options = {...defaultOptions, ...baseOptions}
1548 return Apollo.useMutation<BugStatusCloseMutation, BugStatusCloseMutationVariables>(BugStatusCloseDocument, options);
1549 }
1550export type BugStatusCloseMutationHookResult = ReturnType<typeof useBugStatusCloseMutation>;
1551export type BugStatusCloseMutationResult = Apollo.MutationResult<BugStatusCloseMutation>;
1552export type BugStatusCloseMutationOptions = Apollo.BaseMutationOptions<BugStatusCloseMutation, BugStatusCloseMutationVariables>;
1553export const BugSetTitleDocument = gql`
1554 mutation BugSetTitle($input: BugSetTitleInput!) {
1555 bugSetTitle(input: $input) {
1556 bug {
1557 id
1558 title
1559 }
1560 }
1561}
1562 `;
1563export type BugSetTitleMutationFn = Apollo.MutationFunction<BugSetTitleMutation, BugSetTitleMutationVariables>;
1564
1565/**
1566 * __useBugSetTitleMutation__
1567 *
1568 * To run a mutation, you first call `useBugSetTitleMutation` within a React component and pass it any options that fit your needs.
1569 * When your component renders, `useBugSetTitleMutation` returns a tuple that includes:
1570 * - A mutate function that you can call at any time to execute the mutation
1571 * - An object with fields that represent the current status of the mutation's execution
1572 *
1573 * @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;
1574 *
1575 * @example
1576 * const [bugSetTitleMutation, { data, loading, error }] = useBugSetTitleMutation({
1577 * variables: {
1578 * input: // value for 'input'
1579 * },
1580 * });
1581 */
1582export function useBugSetTitleMutation(baseOptions?: Apollo.MutationHookOptions<BugSetTitleMutation, BugSetTitleMutationVariables>) {
1583 const options = {...defaultOptions, ...baseOptions}
1584 return Apollo.useMutation<BugSetTitleMutation, BugSetTitleMutationVariables>(BugSetTitleDocument, options);
1585 }
1586export type BugSetTitleMutationHookResult = ReturnType<typeof useBugSetTitleMutation>;
1587export type BugSetTitleMutationResult = Apollo.MutationResult<BugSetTitleMutation>;
1588export type BugSetTitleMutationOptions = Apollo.BaseMutationOptions<BugSetTitleMutation, BugSetTitleMutationVariables>;
1589export const RepositoriesDocument = gql`
1590 query Repositories {
1591 repositories {
1592 nodes {
1593 name
1594 slug
1595 }
1596 totalCount
1597 }
1598}
1599 `;
1600
1601/**
1602 * __useRepositoriesQuery__
1603 *
1604 * To run a query within a React component, call `useRepositoriesQuery` and pass it any options that fit your needs.
1605 * When your component renders, `useRepositoriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
1606 * you can use to render your UI.
1607 *
1608 * @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;
1609 *
1610 * @example
1611 * const { data, loading, error } = useRepositoriesQuery({
1612 * variables: {
1613 * },
1614 * });
1615 */
1616export function useRepositoriesQuery(baseOptions?: Apollo.QueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1617 const options = {...defaultOptions, ...baseOptions}
1618 return Apollo.useQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1619 }
1620export function useRepositoriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1621 const options = {...defaultOptions, ...baseOptions}
1622 return Apollo.useLazyQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1623 }
1624// @ts-ignore
1625export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>): Apollo.UseSuspenseQueryResult<RepositoriesQuery, RepositoriesQueryVariables>;
1626export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>): Apollo.UseSuspenseQueryResult<RepositoriesQuery | undefined, RepositoriesQueryVariables>;
1627export function useRepositoriesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<RepositoriesQuery, RepositoriesQueryVariables>) {
1628 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1629 return Apollo.useSuspenseQuery<RepositoriesQuery, RepositoriesQueryVariables>(RepositoriesDocument, options);
1630 }
1631export type RepositoriesQueryHookResult = ReturnType<typeof useRepositoriesQuery>;
1632export type RepositoriesLazyQueryHookResult = ReturnType<typeof useRepositoriesLazyQuery>;
1633export type RepositoriesSuspenseQueryHookResult = ReturnType<typeof useRepositoriesSuspenseQuery>;
1634export type RepositoriesQueryResult = Apollo.QueryResult<RepositoriesQuery, RepositoriesQueryVariables>;
1635export const ServerConfigDocument = gql`
1636 query ServerConfig {
1637 serverConfig {
1638 authMode
1639 oauthProviders
1640 }
1641}
1642 `;
1643
1644/**
1645 * __useServerConfigQuery__
1646 *
1647 * To run a query within a React component, call `useServerConfigQuery` and pass it any options that fit your needs.
1648 * When your component renders, `useServerConfigQuery` returns an object from Apollo Client that contains loading, error, and data properties
1649 * you can use to render your UI.
1650 *
1651 * @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;
1652 *
1653 * @example
1654 * const { data, loading, error } = useServerConfigQuery({
1655 * variables: {
1656 * },
1657 * });
1658 */
1659export function useServerConfigQuery(baseOptions?: Apollo.QueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1660 const options = {...defaultOptions, ...baseOptions}
1661 return Apollo.useQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1662 }
1663export function useServerConfigLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1664 const options = {...defaultOptions, ...baseOptions}
1665 return Apollo.useLazyQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1666 }
1667// @ts-ignore
1668export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>): Apollo.UseSuspenseQueryResult<ServerConfigQuery, ServerConfigQueryVariables>;
1669export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>): Apollo.UseSuspenseQueryResult<ServerConfigQuery | undefined, ServerConfigQueryVariables>;
1670export function useServerConfigSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ServerConfigQuery, ServerConfigQueryVariables>) {
1671 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1672 return Apollo.useSuspenseQuery<ServerConfigQuery, ServerConfigQueryVariables>(ServerConfigDocument, options);
1673 }
1674export type ServerConfigQueryHookResult = ReturnType<typeof useServerConfigQuery>;
1675export type ServerConfigLazyQueryHookResult = ReturnType<typeof useServerConfigLazyQuery>;
1676export type ServerConfigSuspenseQueryHookResult = ReturnType<typeof useServerConfigSuspenseQuery>;
1677export type ServerConfigQueryResult = Apollo.QueryResult<ServerConfigQuery, ServerConfigQueryVariables>;
1678export const UserProfileDocument = gql`
1679 query UserProfile($ref: String, $prefix: String!, $openQuery: String!, $closedQuery: String!, $listQuery: String!, $after: String) {
1680 repository(ref: $ref) {
1681 identity(prefix: $prefix) {
1682 id
1683 humanId
1684 name
1685 email
1686 login
1687 displayName
1688 avatarUrl
1689 isProtected
1690 }
1691 openCount: allBugs(query: $openQuery, first: 1) {
1692 totalCount
1693 }
1694 closedCount: allBugs(query: $closedQuery, first: 1) {
1695 totalCount
1696 }
1697 bugs: allBugs(query: $listQuery, first: 25, after: $after) {
1698 totalCount
1699 pageInfo {
1700 hasNextPage
1701 endCursor
1702 }
1703 nodes {
1704 id
1705 humanId
1706 status
1707 title
1708 labels {
1709 name
1710 color {
1711 R
1712 G
1713 B
1714 }
1715 }
1716 createdAt
1717 comments {
1718 totalCount
1719 }
1720 }
1721 }
1722 }
1723}
1724 `;
1725
1726/**
1727 * __useUserProfileQuery__
1728 *
1729 * To run a query within a React component, call `useUserProfileQuery` and pass it any options that fit your needs.
1730 * When your component renders, `useUserProfileQuery` returns an object from Apollo Client that contains loading, error, and data properties
1731 * you can use to render your UI.
1732 *
1733 * @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;
1734 *
1735 * @example
1736 * const { data, loading, error } = useUserProfileQuery({
1737 * variables: {
1738 * ref: // value for 'ref'
1739 * prefix: // value for 'prefix'
1740 * openQuery: // value for 'openQuery'
1741 * closedQuery: // value for 'closedQuery'
1742 * listQuery: // value for 'listQuery'
1743 * after: // value for 'after'
1744 * },
1745 * });
1746 */
1747export function useUserProfileQuery(baseOptions: Apollo.QueryHookOptions<UserProfileQuery, UserProfileQueryVariables> & ({ variables: UserProfileQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
1748 const options = {...defaultOptions, ...baseOptions}
1749 return Apollo.useQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1750 }
1751export function useUserProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {
1752 const options = {...defaultOptions, ...baseOptions}
1753 return Apollo.useLazyQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1754 }
1755// @ts-ignore
1756export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>): Apollo.UseSuspenseQueryResult<UserProfileQuery, UserProfileQueryVariables>;
1757export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>): Apollo.UseSuspenseQueryResult<UserProfileQuery | undefined, UserProfileQueryVariables>;
1758export function useUserProfileSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UserProfileQuery, UserProfileQueryVariables>) {
1759 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1760 return Apollo.useSuspenseQuery<UserProfileQuery, UserProfileQueryVariables>(UserProfileDocument, options);
1761 }
1762export type UserProfileQueryHookResult = ReturnType<typeof useUserProfileQuery>;
1763export type UserProfileLazyQueryHookResult = ReturnType<typeof useUserProfileLazyQuery>;
1764export type UserProfileSuspenseQueryHookResult = ReturnType<typeof useUserProfileSuspenseQuery>;
1765export type UserProfileQueryResult = Apollo.QueryResult<UserProfileQuery, UserProfileQueryVariables>;
1766export const ValidLabelsDocument = gql`
1767 query ValidLabels($ref: String) {
1768 repository(ref: $ref) {
1769 validLabels {
1770 nodes {
1771 name
1772 color {
1773 R
1774 G
1775 B
1776 }
1777 }
1778 }
1779 }
1780}
1781 `;
1782
1783/**
1784 * __useValidLabelsQuery__
1785 *
1786 * To run a query within a React component, call `useValidLabelsQuery` and pass it any options that fit your needs.
1787 * When your component renders, `useValidLabelsQuery` returns an object from Apollo Client that contains loading, error, and data properties
1788 * you can use to render your UI.
1789 *
1790 * @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;
1791 *
1792 * @example
1793 * const { data, loading, error } = useValidLabelsQuery({
1794 * variables: {
1795 * ref: // value for 'ref'
1796 * },
1797 * });
1798 */
1799export function useValidLabelsQuery(baseOptions?: Apollo.QueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1800 const options = {...defaultOptions, ...baseOptions}
1801 return Apollo.useQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1802 }
1803export function useValidLabelsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1804 const options = {...defaultOptions, ...baseOptions}
1805 return Apollo.useLazyQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1806 }
1807// @ts-ignore
1808export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>): Apollo.UseSuspenseQueryResult<ValidLabelsQuery, ValidLabelsQueryVariables>;
1809export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>): Apollo.UseSuspenseQueryResult<ValidLabelsQuery | undefined, ValidLabelsQueryVariables>;
1810export function useValidLabelsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ValidLabelsQuery, ValidLabelsQueryVariables>) {
1811 const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
1812 return Apollo.useSuspenseQuery<ValidLabelsQuery, ValidLabelsQueryVariables>(ValidLabelsDocument, options);
1813 }
1814export type ValidLabelsQueryHookResult = ReturnType<typeof useValidLabelsQuery>;
1815export type ValidLabelsLazyQueryHookResult = ReturnType<typeof useValidLabelsLazyQuery>;
1816export type ValidLabelsSuspenseQueryHookResult = ReturnType<typeof useValidLabelsSuspenseQuery>;
1817export type ValidLabelsQueryResult = Apollo.QueryResult<ValidLabelsQuery, ValidLabelsQueryVariables>;