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