@burdenoff/microfe-support 2026.801.1 → 2026.817.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/generated/global-operations.d.ts +1464 -19
- package/dist/generated/global-operations.js +925 -133
- package/dist/generated/global-operations.js.map +1 -1
- package/dist/generated/global-types.d.ts +546 -0
- package/dist/generated/global-types.js +21 -7
- package/dist/generated/global-types.js.map +1 -1
- package/dist/support/SupportAdminRoot.js +53 -37
- package/dist/support/SupportAdminRoot.js.map +1 -1
- package/dist/support/SupportAdminRoutes.js +23 -11
- package/dist/support/SupportAdminRoutes.js.map +1 -1
- package/dist/support/components/ui.js +2 -2
- package/dist/support/pages/InterviewersPage.d.ts +1 -0
- package/dist/support/pages/InterviewersPage.js +459 -0
- package/dist/support/pages/InterviewersPage.js.map +1 -0
- package/dist/support/pages/JobApplicationDetailPage.js +1007 -268
- package/dist/support/pages/JobApplicationDetailPage.js.map +1 -1
- package/dist/support/pages/JobApplicationsPage.js +327 -213
- package/dist/support/pages/JobApplicationsPage.js.map +1 -1
- package/dist/support/pages/JobPostingDetailPage.d.ts +1 -0
- package/dist/support/pages/JobPostingDetailPage.js +996 -0
- package/dist/support/pages/JobPostingDetailPage.js.map +1 -0
- package/dist/support/pages/JobPostingsPage.d.ts +1 -0
- package/dist/support/pages/JobPostingsPage.js +544 -0
- package/dist/support/pages/JobPostingsPage.js.map +1 -0
- package/dist/support/pages/SettingsPage.js.map +1 -1
- package/dist/support/pages/TicketDetailUserPage.js.map +1 -1
- package/package.json +2 -2
|
@@ -142,6 +142,49 @@ export type CreateSupportMessageMutation = {
|
|
|
142
142
|
updatedAt: string;
|
|
143
143
|
};
|
|
144
144
|
};
|
|
145
|
+
export type AssignInterviewersToRoundMutationVariables = Types.Exact<{
|
|
146
|
+
input: Types.AssignInterviewersToRoundInput;
|
|
147
|
+
}>;
|
|
148
|
+
export type AssignInterviewersToRoundMutation = {
|
|
149
|
+
__typename?: 'Mutation';
|
|
150
|
+
assignInterviewersToRound: {
|
|
151
|
+
__typename?: 'InterviewRound';
|
|
152
|
+
id: string;
|
|
153
|
+
applicationId: string;
|
|
154
|
+
roundConfigId?: string | null;
|
|
155
|
+
name: string;
|
|
156
|
+
roundType: Types.InterviewRoundType;
|
|
157
|
+
status: Types.InterviewRoundStatus;
|
|
158
|
+
scheduledAt?: string | null;
|
|
159
|
+
notes?: string | null;
|
|
160
|
+
candidateMessage?: string | null;
|
|
161
|
+
candidateMessageSentAt?: string | null;
|
|
162
|
+
assignmentId?: string | null;
|
|
163
|
+
submittedRepoUrl?: string | null;
|
|
164
|
+
submittedVideoUrl?: string | null;
|
|
165
|
+
submittedAt?: string | null;
|
|
166
|
+
submittedNotes?: string | null;
|
|
167
|
+
context?: Record<string, unknown> | null;
|
|
168
|
+
createdAt: string;
|
|
169
|
+
updatedAt: string;
|
|
170
|
+
createdBy: string;
|
|
171
|
+
onBehalfOf: string;
|
|
172
|
+
updatedBy?: string | null;
|
|
173
|
+
interviewers: Array<{
|
|
174
|
+
__typename?: 'InterviewRoundInterviewer';
|
|
175
|
+
id: string;
|
|
176
|
+
role: Types.InterviewerRole;
|
|
177
|
+
assignedAt: string;
|
|
178
|
+
interviewer: {
|
|
179
|
+
__typename?: 'Interviewer';
|
|
180
|
+
id: string;
|
|
181
|
+
name: string;
|
|
182
|
+
email: string;
|
|
183
|
+
title?: string | null;
|
|
184
|
+
};
|
|
185
|
+
}>;
|
|
186
|
+
};
|
|
187
|
+
};
|
|
145
188
|
export type AssignSupportTicketMutationVariables = Types.Exact<{
|
|
146
189
|
id: Types.Scalars['ID']['input'];
|
|
147
190
|
assignedTo: Types.Scalars['String']['input'];
|
|
@@ -212,6 +255,127 @@ export type CreateCannedResponseMutation = {
|
|
|
212
255
|
updatedAt: string;
|
|
213
256
|
};
|
|
214
257
|
};
|
|
258
|
+
export type CreateInterviewRoundMutationVariables = Types.Exact<{
|
|
259
|
+
input: Types.CreateInterviewRoundInput;
|
|
260
|
+
}>;
|
|
261
|
+
export type CreateInterviewRoundMutation = {
|
|
262
|
+
__typename?: 'Mutation';
|
|
263
|
+
createInterviewRound: {
|
|
264
|
+
__typename?: 'InterviewRound';
|
|
265
|
+
id: string;
|
|
266
|
+
applicationId: string;
|
|
267
|
+
roundConfigId?: string | null;
|
|
268
|
+
name: string;
|
|
269
|
+
roundType: Types.InterviewRoundType;
|
|
270
|
+
status: Types.InterviewRoundStatus;
|
|
271
|
+
scheduledAt?: string | null;
|
|
272
|
+
notes?: string | null;
|
|
273
|
+
candidateMessage?: string | null;
|
|
274
|
+
candidateMessageSentAt?: string | null;
|
|
275
|
+
assignmentId?: string | null;
|
|
276
|
+
submittedRepoUrl?: string | null;
|
|
277
|
+
submittedVideoUrl?: string | null;
|
|
278
|
+
submittedAt?: string | null;
|
|
279
|
+
submittedNotes?: string | null;
|
|
280
|
+
context?: Record<string, unknown> | null;
|
|
281
|
+
createdAt: string;
|
|
282
|
+
updatedAt: string;
|
|
283
|
+
createdBy: string;
|
|
284
|
+
onBehalfOf: string;
|
|
285
|
+
updatedBy?: string | null;
|
|
286
|
+
};
|
|
287
|
+
};
|
|
288
|
+
export type CreateInterviewRoundConfigMutationVariables = Types.Exact<{
|
|
289
|
+
input: Types.CreateInterviewRoundConfigInput;
|
|
290
|
+
}>;
|
|
291
|
+
export type CreateInterviewRoundConfigMutation = {
|
|
292
|
+
__typename?: 'Mutation';
|
|
293
|
+
createInterviewRoundConfig: {
|
|
294
|
+
__typename?: 'InterviewRoundConfig';
|
|
295
|
+
id: string;
|
|
296
|
+
jobPostingId: string;
|
|
297
|
+
roundNumber: number;
|
|
298
|
+
name: string;
|
|
299
|
+
description?: string | null;
|
|
300
|
+
roundType: Types.InterviewRoundType;
|
|
301
|
+
isAssignmentRound: boolean;
|
|
302
|
+
isRequired: boolean;
|
|
303
|
+
context?: Record<string, unknown> | null;
|
|
304
|
+
createdAt: string;
|
|
305
|
+
updatedAt: string;
|
|
306
|
+
createdBy: string;
|
|
307
|
+
onBehalfOf: string;
|
|
308
|
+
updatedBy?: string | null;
|
|
309
|
+
};
|
|
310
|
+
};
|
|
311
|
+
export type CreateInterviewerMutationVariables = Types.Exact<{
|
|
312
|
+
input: Types.CreateInterviewerInput;
|
|
313
|
+
}>;
|
|
314
|
+
export type CreateInterviewerMutation = {
|
|
315
|
+
__typename?: 'Mutation';
|
|
316
|
+
createInterviewer: {
|
|
317
|
+
__typename?: 'Interviewer';
|
|
318
|
+
id: string;
|
|
319
|
+
name: string;
|
|
320
|
+
email: string;
|
|
321
|
+
userId?: string | null;
|
|
322
|
+
department?: string | null;
|
|
323
|
+
title?: string | null;
|
|
324
|
+
isActive: boolean;
|
|
325
|
+
notes?: string | null;
|
|
326
|
+
context?: Record<string, unknown> | null;
|
|
327
|
+
createdAt: string;
|
|
328
|
+
updatedAt: string;
|
|
329
|
+
createdBy: string;
|
|
330
|
+
onBehalfOf: string;
|
|
331
|
+
updatedBy?: string | null;
|
|
332
|
+
};
|
|
333
|
+
};
|
|
334
|
+
export type CreateJobAssignmentMutationVariables = Types.Exact<{
|
|
335
|
+
input: Types.CreateJobAssignmentInput;
|
|
336
|
+
}>;
|
|
337
|
+
export type CreateJobAssignmentMutation = {
|
|
338
|
+
__typename?: 'Mutation';
|
|
339
|
+
createJobAssignment: {
|
|
340
|
+
__typename?: 'JobAssignment';
|
|
341
|
+
id: string;
|
|
342
|
+
jobPostingId: string;
|
|
343
|
+
title: string;
|
|
344
|
+
description: string;
|
|
345
|
+
problemStatement?: string | null;
|
|
346
|
+
difficulty?: string | null;
|
|
347
|
+
isActive: boolean;
|
|
348
|
+
context?: Record<string, unknown> | null;
|
|
349
|
+
createdAt: string;
|
|
350
|
+
updatedAt: string;
|
|
351
|
+
createdBy: string;
|
|
352
|
+
onBehalfOf: string;
|
|
353
|
+
updatedBy?: string | null;
|
|
354
|
+
};
|
|
355
|
+
};
|
|
356
|
+
export type CreateJobPostingMutationVariables = Types.Exact<{
|
|
357
|
+
input: Types.CreateJobPostingInput;
|
|
358
|
+
}>;
|
|
359
|
+
export type CreateJobPostingMutation = {
|
|
360
|
+
__typename?: 'Mutation';
|
|
361
|
+
createJobPosting: {
|
|
362
|
+
__typename?: 'JobPosting';
|
|
363
|
+
id: string;
|
|
364
|
+
title: string;
|
|
365
|
+
department?: string | null;
|
|
366
|
+
location?: string | null;
|
|
367
|
+
employmentType?: Types.EmploymentType | null;
|
|
368
|
+
description?: string | null;
|
|
369
|
+
productId?: string | null;
|
|
370
|
+
status: Types.JobPostingStatus;
|
|
371
|
+
context?: Record<string, unknown> | null;
|
|
372
|
+
createdAt: string;
|
|
373
|
+
updatedAt: string;
|
|
374
|
+
createdBy: string;
|
|
375
|
+
onBehalfOf: string;
|
|
376
|
+
updatedBy?: string | null;
|
|
377
|
+
};
|
|
378
|
+
};
|
|
215
379
|
export type CreateSlaPolicyMutationVariables = Types.Exact<{
|
|
216
380
|
input: Types.CreateSlaPolicyInput;
|
|
217
381
|
}>;
|
|
@@ -273,6 +437,48 @@ export type DeleteCannedResponseMutation = {
|
|
|
273
437
|
__typename?: 'Mutation';
|
|
274
438
|
deleteCannedResponse: boolean;
|
|
275
439
|
};
|
|
440
|
+
export type DeleteInterviewFeedbackMutationVariables = Types.Exact<{
|
|
441
|
+
id: Types.Scalars['ID']['input'];
|
|
442
|
+
}>;
|
|
443
|
+
export type DeleteInterviewFeedbackMutation = {
|
|
444
|
+
__typename?: 'Mutation';
|
|
445
|
+
deleteInterviewFeedback: boolean;
|
|
446
|
+
};
|
|
447
|
+
export type DeleteInterviewRoundMutationVariables = Types.Exact<{
|
|
448
|
+
id: Types.Scalars['ID']['input'];
|
|
449
|
+
}>;
|
|
450
|
+
export type DeleteInterviewRoundMutation = {
|
|
451
|
+
__typename?: 'Mutation';
|
|
452
|
+
deleteInterviewRound: boolean;
|
|
453
|
+
};
|
|
454
|
+
export type DeleteInterviewRoundConfigMutationVariables = Types.Exact<{
|
|
455
|
+
id: Types.Scalars['ID']['input'];
|
|
456
|
+
}>;
|
|
457
|
+
export type DeleteInterviewRoundConfigMutation = {
|
|
458
|
+
__typename?: 'Mutation';
|
|
459
|
+
deleteInterviewRoundConfig: boolean;
|
|
460
|
+
};
|
|
461
|
+
export type DeleteInterviewerMutationVariables = Types.Exact<{
|
|
462
|
+
id: Types.Scalars['ID']['input'];
|
|
463
|
+
}>;
|
|
464
|
+
export type DeleteInterviewerMutation = {
|
|
465
|
+
__typename?: 'Mutation';
|
|
466
|
+
deleteInterviewer: boolean;
|
|
467
|
+
};
|
|
468
|
+
export type DeleteJobAssignmentMutationVariables = Types.Exact<{
|
|
469
|
+
id: Types.Scalars['ID']['input'];
|
|
470
|
+
}>;
|
|
471
|
+
export type DeleteJobAssignmentMutation = {
|
|
472
|
+
__typename?: 'Mutation';
|
|
473
|
+
deleteJobAssignment: boolean;
|
|
474
|
+
};
|
|
475
|
+
export type DeleteJobPostingMutationVariables = Types.Exact<{
|
|
476
|
+
id: Types.Scalars['ID']['input'];
|
|
477
|
+
}>;
|
|
478
|
+
export type DeleteJobPostingMutation = {
|
|
479
|
+
__typename?: 'Mutation';
|
|
480
|
+
deleteJobPosting: boolean;
|
|
481
|
+
};
|
|
276
482
|
export type DeleteSlaPolicyMutationVariables = Types.Exact<{
|
|
277
483
|
id: Types.Scalars['ID']['input'];
|
|
278
484
|
}>;
|
|
@@ -280,6 +486,44 @@ export type DeleteSlaPolicyMutation = {
|
|
|
280
486
|
__typename?: 'Mutation';
|
|
281
487
|
deleteSLAPolicy: boolean;
|
|
282
488
|
};
|
|
489
|
+
export type RandomizeAndSendAssignmentMutationVariables = Types.Exact<{
|
|
490
|
+
input: Types.RandomizeAndSendAssignmentInput;
|
|
491
|
+
}>;
|
|
492
|
+
export type RandomizeAndSendAssignmentMutation = {
|
|
493
|
+
__typename?: 'Mutation';
|
|
494
|
+
randomizeAndSendAssignment: {
|
|
495
|
+
__typename?: 'InterviewRound';
|
|
496
|
+
id: string;
|
|
497
|
+
applicationId: string;
|
|
498
|
+
roundConfigId?: string | null;
|
|
499
|
+
name: string;
|
|
500
|
+
roundType: Types.InterviewRoundType;
|
|
501
|
+
status: Types.InterviewRoundStatus;
|
|
502
|
+
scheduledAt?: string | null;
|
|
503
|
+
notes?: string | null;
|
|
504
|
+
candidateMessage?: string | null;
|
|
505
|
+
candidateMessageSentAt?: string | null;
|
|
506
|
+
assignmentId?: string | null;
|
|
507
|
+
submittedRepoUrl?: string | null;
|
|
508
|
+
submittedVideoUrl?: string | null;
|
|
509
|
+
submittedAt?: string | null;
|
|
510
|
+
submittedNotes?: string | null;
|
|
511
|
+
context?: Record<string, unknown> | null;
|
|
512
|
+
createdAt: string;
|
|
513
|
+
updatedAt: string;
|
|
514
|
+
createdBy: string;
|
|
515
|
+
onBehalfOf: string;
|
|
516
|
+
updatedBy?: string | null;
|
|
517
|
+
assignment?: {
|
|
518
|
+
__typename?: 'JobAssignment';
|
|
519
|
+
id: string;
|
|
520
|
+
title: string;
|
|
521
|
+
description: string;
|
|
522
|
+
problemStatement?: string | null;
|
|
523
|
+
difficulty?: string | null;
|
|
524
|
+
} | null;
|
|
525
|
+
};
|
|
526
|
+
};
|
|
283
527
|
export type RateArticleMutationVariables = Types.Exact<{
|
|
284
528
|
id: Types.Scalars['ID']['input'];
|
|
285
529
|
helpful: Types.Scalars['Boolean']['input'];
|
|
@@ -304,6 +548,44 @@ export type RecordArticleViewMutation = {
|
|
|
304
548
|
viewCount: number;
|
|
305
549
|
};
|
|
306
550
|
};
|
|
551
|
+
export type RecordAssignmentSubmissionMutationVariables = Types.Exact<{
|
|
552
|
+
input: Types.RecordAssignmentSubmissionInput;
|
|
553
|
+
}>;
|
|
554
|
+
export type RecordAssignmentSubmissionMutation = {
|
|
555
|
+
__typename?: 'Mutation';
|
|
556
|
+
recordAssignmentSubmission: {
|
|
557
|
+
__typename?: 'InterviewRound';
|
|
558
|
+
id: string;
|
|
559
|
+
applicationId: string;
|
|
560
|
+
roundConfigId?: string | null;
|
|
561
|
+
name: string;
|
|
562
|
+
roundType: Types.InterviewRoundType;
|
|
563
|
+
status: Types.InterviewRoundStatus;
|
|
564
|
+
scheduledAt?: string | null;
|
|
565
|
+
notes?: string | null;
|
|
566
|
+
candidateMessage?: string | null;
|
|
567
|
+
candidateMessageSentAt?: string | null;
|
|
568
|
+
assignmentId?: string | null;
|
|
569
|
+
submittedRepoUrl?: string | null;
|
|
570
|
+
submittedVideoUrl?: string | null;
|
|
571
|
+
submittedAt?: string | null;
|
|
572
|
+
submittedNotes?: string | null;
|
|
573
|
+
context?: Record<string, unknown> | null;
|
|
574
|
+
createdAt: string;
|
|
575
|
+
updatedAt: string;
|
|
576
|
+
createdBy: string;
|
|
577
|
+
onBehalfOf: string;
|
|
578
|
+
updatedBy?: string | null;
|
|
579
|
+
};
|
|
580
|
+
};
|
|
581
|
+
export type RemoveInterviewerFromRoundMutationVariables = Types.Exact<{
|
|
582
|
+
roundId: Types.Scalars['ID']['input'];
|
|
583
|
+
interviewerId: Types.Scalars['ID']['input'];
|
|
584
|
+
}>;
|
|
585
|
+
export type RemoveInterviewerFromRoundMutation = {
|
|
586
|
+
__typename?: 'Mutation';
|
|
587
|
+
removeInterviewerFromRound: boolean;
|
|
588
|
+
};
|
|
307
589
|
export type ReplyToContactInquiryMutationVariables = Types.Exact<{
|
|
308
590
|
id: Types.Scalars['ID']['input'];
|
|
309
591
|
message: Types.Scalars['String']['input'];
|
|
@@ -343,6 +625,64 @@ export type ResolveSupportTicketMutation = {
|
|
|
343
625
|
updatedAt: string;
|
|
344
626
|
};
|
|
345
627
|
};
|
|
628
|
+
export type SendRoundMessageToCandidateMutationVariables = Types.Exact<{
|
|
629
|
+
input: Types.SendRoundMessageToCandidateInput;
|
|
630
|
+
}>;
|
|
631
|
+
export type SendRoundMessageToCandidateMutation = {
|
|
632
|
+
__typename?: 'Mutation';
|
|
633
|
+
sendRoundMessageToCandidate: {
|
|
634
|
+
__typename?: 'InterviewRound';
|
|
635
|
+
id: string;
|
|
636
|
+
applicationId: string;
|
|
637
|
+
roundConfigId?: string | null;
|
|
638
|
+
name: string;
|
|
639
|
+
roundType: Types.InterviewRoundType;
|
|
640
|
+
status: Types.InterviewRoundStatus;
|
|
641
|
+
scheduledAt?: string | null;
|
|
642
|
+
notes?: string | null;
|
|
643
|
+
candidateMessage?: string | null;
|
|
644
|
+
candidateMessageSentAt?: string | null;
|
|
645
|
+
assignmentId?: string | null;
|
|
646
|
+
submittedRepoUrl?: string | null;
|
|
647
|
+
submittedVideoUrl?: string | null;
|
|
648
|
+
submittedAt?: string | null;
|
|
649
|
+
submittedNotes?: string | null;
|
|
650
|
+
context?: Record<string, unknown> | null;
|
|
651
|
+
createdAt: string;
|
|
652
|
+
updatedAt: string;
|
|
653
|
+
createdBy: string;
|
|
654
|
+
onBehalfOf: string;
|
|
655
|
+
updatedBy?: string | null;
|
|
656
|
+
};
|
|
657
|
+
};
|
|
658
|
+
export type SubmitInterviewFeedbackMutationVariables = Types.Exact<{
|
|
659
|
+
input: Types.SubmitInterviewFeedbackInput;
|
|
660
|
+
}>;
|
|
661
|
+
export type SubmitInterviewFeedbackMutation = {
|
|
662
|
+
__typename?: 'Mutation';
|
|
663
|
+
submitInterviewFeedback: {
|
|
664
|
+
__typename?: 'InterviewFeedback';
|
|
665
|
+
id: string;
|
|
666
|
+
roundId: string;
|
|
667
|
+
interviewerId: string;
|
|
668
|
+
rating?: number | null;
|
|
669
|
+
verdict?: Types.InterviewVerdict | null;
|
|
670
|
+
internalNotes?: string | null;
|
|
671
|
+
context?: Record<string, unknown> | null;
|
|
672
|
+
createdAt: string;
|
|
673
|
+
updatedAt: string;
|
|
674
|
+
createdBy: string;
|
|
675
|
+
onBehalfOf: string;
|
|
676
|
+
updatedBy?: string | null;
|
|
677
|
+
interviewer: {
|
|
678
|
+
__typename?: 'Interviewer';
|
|
679
|
+
id: string;
|
|
680
|
+
name: string;
|
|
681
|
+
email: string;
|
|
682
|
+
title?: string | null;
|
|
683
|
+
};
|
|
684
|
+
};
|
|
685
|
+
};
|
|
346
686
|
export type SubmitSatisfactionSurveyMutationVariables = Types.Exact<{
|
|
347
687
|
input: Types.SubmitSatisfactionSurveyInput;
|
|
348
688
|
}>;
|
|
@@ -388,6 +728,114 @@ export type UpdateContactInquiryStatusMutation = {
|
|
|
388
728
|
updatedAt: string;
|
|
389
729
|
};
|
|
390
730
|
};
|
|
731
|
+
export type UpdateInterviewFeedbackMutationVariables = Types.Exact<{
|
|
732
|
+
id: Types.Scalars['ID']['input'];
|
|
733
|
+
input: Types.UpdateInterviewFeedbackInput;
|
|
734
|
+
}>;
|
|
735
|
+
export type UpdateInterviewFeedbackMutation = {
|
|
736
|
+
__typename?: 'Mutation';
|
|
737
|
+
updateInterviewFeedback: {
|
|
738
|
+
__typename?: 'InterviewFeedback';
|
|
739
|
+
id: string;
|
|
740
|
+
roundId: string;
|
|
741
|
+
interviewerId: string;
|
|
742
|
+
rating?: number | null;
|
|
743
|
+
verdict?: Types.InterviewVerdict | null;
|
|
744
|
+
internalNotes?: string | null;
|
|
745
|
+
context?: Record<string, unknown> | null;
|
|
746
|
+
createdAt: string;
|
|
747
|
+
updatedAt: string;
|
|
748
|
+
createdBy: string;
|
|
749
|
+
onBehalfOf: string;
|
|
750
|
+
updatedBy?: string | null;
|
|
751
|
+
interviewer: {
|
|
752
|
+
__typename?: 'Interviewer';
|
|
753
|
+
id: string;
|
|
754
|
+
name: string;
|
|
755
|
+
email: string;
|
|
756
|
+
title?: string | null;
|
|
757
|
+
};
|
|
758
|
+
};
|
|
759
|
+
};
|
|
760
|
+
export type UpdateInterviewRoundMutationVariables = Types.Exact<{
|
|
761
|
+
id: Types.Scalars['ID']['input'];
|
|
762
|
+
input: Types.UpdateInterviewRoundInput;
|
|
763
|
+
}>;
|
|
764
|
+
export type UpdateInterviewRoundMutation = {
|
|
765
|
+
__typename?: 'Mutation';
|
|
766
|
+
updateInterviewRound: {
|
|
767
|
+
__typename?: 'InterviewRound';
|
|
768
|
+
id: string;
|
|
769
|
+
applicationId: string;
|
|
770
|
+
roundConfigId?: string | null;
|
|
771
|
+
name: string;
|
|
772
|
+
roundType: Types.InterviewRoundType;
|
|
773
|
+
status: Types.InterviewRoundStatus;
|
|
774
|
+
scheduledAt?: string | null;
|
|
775
|
+
notes?: string | null;
|
|
776
|
+
candidateMessage?: string | null;
|
|
777
|
+
candidateMessageSentAt?: string | null;
|
|
778
|
+
assignmentId?: string | null;
|
|
779
|
+
submittedRepoUrl?: string | null;
|
|
780
|
+
submittedVideoUrl?: string | null;
|
|
781
|
+
submittedAt?: string | null;
|
|
782
|
+
submittedNotes?: string | null;
|
|
783
|
+
context?: Record<string, unknown> | null;
|
|
784
|
+
createdAt: string;
|
|
785
|
+
updatedAt: string;
|
|
786
|
+
createdBy: string;
|
|
787
|
+
onBehalfOf: string;
|
|
788
|
+
updatedBy?: string | null;
|
|
789
|
+
};
|
|
790
|
+
};
|
|
791
|
+
export type UpdateInterviewRoundConfigMutationVariables = Types.Exact<{
|
|
792
|
+
id: Types.Scalars['ID']['input'];
|
|
793
|
+
input: Types.UpdateInterviewRoundConfigInput;
|
|
794
|
+
}>;
|
|
795
|
+
export type UpdateInterviewRoundConfigMutation = {
|
|
796
|
+
__typename?: 'Mutation';
|
|
797
|
+
updateInterviewRoundConfig: {
|
|
798
|
+
__typename?: 'InterviewRoundConfig';
|
|
799
|
+
id: string;
|
|
800
|
+
jobPostingId: string;
|
|
801
|
+
roundNumber: number;
|
|
802
|
+
name: string;
|
|
803
|
+
description?: string | null;
|
|
804
|
+
roundType: Types.InterviewRoundType;
|
|
805
|
+
isAssignmentRound: boolean;
|
|
806
|
+
isRequired: boolean;
|
|
807
|
+
context?: Record<string, unknown> | null;
|
|
808
|
+
createdAt: string;
|
|
809
|
+
updatedAt: string;
|
|
810
|
+
createdBy: string;
|
|
811
|
+
onBehalfOf: string;
|
|
812
|
+
updatedBy?: string | null;
|
|
813
|
+
};
|
|
814
|
+
};
|
|
815
|
+
export type UpdateInterviewerMutationVariables = Types.Exact<{
|
|
816
|
+
id: Types.Scalars['ID']['input'];
|
|
817
|
+
input: Types.UpdateInterviewerInput;
|
|
818
|
+
}>;
|
|
819
|
+
export type UpdateInterviewerMutation = {
|
|
820
|
+
__typename?: 'Mutation';
|
|
821
|
+
updateInterviewer: {
|
|
822
|
+
__typename?: 'Interviewer';
|
|
823
|
+
id: string;
|
|
824
|
+
name: string;
|
|
825
|
+
email: string;
|
|
826
|
+
userId?: string | null;
|
|
827
|
+
department?: string | null;
|
|
828
|
+
title?: string | null;
|
|
829
|
+
isActive: boolean;
|
|
830
|
+
notes?: string | null;
|
|
831
|
+
context?: Record<string, unknown> | null;
|
|
832
|
+
createdAt: string;
|
|
833
|
+
updatedAt: string;
|
|
834
|
+
createdBy: string;
|
|
835
|
+
onBehalfOf: string;
|
|
836
|
+
updatedBy?: string | null;
|
|
837
|
+
};
|
|
838
|
+
};
|
|
391
839
|
export type UpdateJobApplicationStatusMutationVariables = Types.Exact<{
|
|
392
840
|
id: Types.Scalars['ID']['input'];
|
|
393
841
|
input: Types.UpdateJobApplicationStatusInput;
|
|
@@ -401,6 +849,53 @@ export type UpdateJobApplicationStatusMutation = {
|
|
|
401
849
|
updatedAt: string;
|
|
402
850
|
};
|
|
403
851
|
};
|
|
852
|
+
export type UpdateJobAssignmentMutationVariables = Types.Exact<{
|
|
853
|
+
id: Types.Scalars['ID']['input'];
|
|
854
|
+
input: Types.UpdateJobAssignmentInput;
|
|
855
|
+
}>;
|
|
856
|
+
export type UpdateJobAssignmentMutation = {
|
|
857
|
+
__typename?: 'Mutation';
|
|
858
|
+
updateJobAssignment: {
|
|
859
|
+
__typename?: 'JobAssignment';
|
|
860
|
+
id: string;
|
|
861
|
+
jobPostingId: string;
|
|
862
|
+
title: string;
|
|
863
|
+
description: string;
|
|
864
|
+
problemStatement?: string | null;
|
|
865
|
+
difficulty?: string | null;
|
|
866
|
+
isActive: boolean;
|
|
867
|
+
context?: Record<string, unknown> | null;
|
|
868
|
+
createdAt: string;
|
|
869
|
+
updatedAt: string;
|
|
870
|
+
createdBy: string;
|
|
871
|
+
onBehalfOf: string;
|
|
872
|
+
updatedBy?: string | null;
|
|
873
|
+
};
|
|
874
|
+
};
|
|
875
|
+
export type UpdateJobPostingMutationVariables = Types.Exact<{
|
|
876
|
+
id: Types.Scalars['ID']['input'];
|
|
877
|
+
input: Types.UpdateJobPostingInput;
|
|
878
|
+
}>;
|
|
879
|
+
export type UpdateJobPostingMutation = {
|
|
880
|
+
__typename?: 'Mutation';
|
|
881
|
+
updateJobPosting: {
|
|
882
|
+
__typename?: 'JobPosting';
|
|
883
|
+
id: string;
|
|
884
|
+
title: string;
|
|
885
|
+
department?: string | null;
|
|
886
|
+
location?: string | null;
|
|
887
|
+
employmentType?: Types.EmploymentType | null;
|
|
888
|
+
description?: string | null;
|
|
889
|
+
productId?: string | null;
|
|
890
|
+
status: Types.JobPostingStatus;
|
|
891
|
+
context?: Record<string, unknown> | null;
|
|
892
|
+
createdAt: string;
|
|
893
|
+
updatedAt: string;
|
|
894
|
+
createdBy: string;
|
|
895
|
+
onBehalfOf: string;
|
|
896
|
+
updatedBy?: string | null;
|
|
897
|
+
};
|
|
898
|
+
};
|
|
404
899
|
export type UpdateSlaPolicyMutationVariables = Types.Exact<{
|
|
405
900
|
id: Types.Scalars['ID']['input'];
|
|
406
901
|
input: Types.UpdateSlaPolicyInput;
|
|
@@ -705,6 +1200,54 @@ export type GetContactInquiryQuery = {
|
|
|
705
1200
|
updatedAt: string;
|
|
706
1201
|
} | null;
|
|
707
1202
|
};
|
|
1203
|
+
export type GetInterviewerQueryVariables = Types.Exact<{
|
|
1204
|
+
id: Types.Scalars['ID']['input'];
|
|
1205
|
+
}>;
|
|
1206
|
+
export type GetInterviewerQuery = {
|
|
1207
|
+
__typename?: 'Query';
|
|
1208
|
+
interviewer?: {
|
|
1209
|
+
__typename?: 'Interviewer';
|
|
1210
|
+
id: string;
|
|
1211
|
+
name: string;
|
|
1212
|
+
email: string;
|
|
1213
|
+
userId?: string | null;
|
|
1214
|
+
department?: string | null;
|
|
1215
|
+
title?: string | null;
|
|
1216
|
+
isActive: boolean;
|
|
1217
|
+
notes?: string | null;
|
|
1218
|
+
context?: Record<string, unknown> | null;
|
|
1219
|
+
createdAt: string;
|
|
1220
|
+
updatedAt: string;
|
|
1221
|
+
createdBy: string;
|
|
1222
|
+
onBehalfOf: string;
|
|
1223
|
+
updatedBy?: string | null;
|
|
1224
|
+
} | null;
|
|
1225
|
+
};
|
|
1226
|
+
export type GetInterviewersQueryVariables = Types.Exact<{
|
|
1227
|
+
filter?: Types.InputMaybe<Types.InterviewerFilterInput>;
|
|
1228
|
+
limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
|
|
1229
|
+
offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
|
|
1230
|
+
}>;
|
|
1231
|
+
export type GetInterviewersQuery = {
|
|
1232
|
+
__typename?: 'Query';
|
|
1233
|
+
interviewers: {
|
|
1234
|
+
__typename?: 'InterviewerList';
|
|
1235
|
+
total: number;
|
|
1236
|
+
hasMore: boolean;
|
|
1237
|
+
items: Array<{
|
|
1238
|
+
__typename?: 'Interviewer';
|
|
1239
|
+
id: string;
|
|
1240
|
+
name: string;
|
|
1241
|
+
email: string;
|
|
1242
|
+
userId?: string | null;
|
|
1243
|
+
department?: string | null;
|
|
1244
|
+
title?: string | null;
|
|
1245
|
+
isActive: boolean;
|
|
1246
|
+
notes?: string | null;
|
|
1247
|
+
createdAt: string;
|
|
1248
|
+
}>;
|
|
1249
|
+
};
|
|
1250
|
+
};
|
|
708
1251
|
export type GetJobApplicationQueryVariables = Types.Exact<{
|
|
709
1252
|
id: Types.Scalars['ID']['input'];
|
|
710
1253
|
}>;
|
|
@@ -726,13 +1269,103 @@ export type GetJobApplicationQuery = {
|
|
|
726
1269
|
resumeFileSize?: number | null;
|
|
727
1270
|
resumeMimeType?: string | null;
|
|
728
1271
|
productId?: string | null;
|
|
1272
|
+
jobPostingId?: string | null;
|
|
729
1273
|
source: string;
|
|
730
1274
|
status: Types.JobApplicationStatus;
|
|
731
1275
|
metadata?: Record<string, unknown> | null;
|
|
732
1276
|
createdAt: string;
|
|
733
1277
|
updatedAt: string;
|
|
1278
|
+
jobPosting?: {
|
|
1279
|
+
__typename?: 'JobPosting';
|
|
1280
|
+
id: string;
|
|
1281
|
+
title: string;
|
|
1282
|
+
department?: string | null;
|
|
1283
|
+
} | null;
|
|
1284
|
+
interviewRounds: Array<{
|
|
1285
|
+
__typename?: 'InterviewRound';
|
|
1286
|
+
id: string;
|
|
1287
|
+
roundConfigId?: string | null;
|
|
1288
|
+
name: string;
|
|
1289
|
+
roundType: Types.InterviewRoundType;
|
|
1290
|
+
status: Types.InterviewRoundStatus;
|
|
1291
|
+
scheduledAt?: string | null;
|
|
1292
|
+
notes?: string | null;
|
|
1293
|
+
candidateMessage?: string | null;
|
|
1294
|
+
candidateMessageSentAt?: string | null;
|
|
1295
|
+
submittedRepoUrl?: string | null;
|
|
1296
|
+
submittedVideoUrl?: string | null;
|
|
1297
|
+
submittedAt?: string | null;
|
|
1298
|
+
submittedNotes?: string | null;
|
|
1299
|
+
}>;
|
|
734
1300
|
} | null;
|
|
735
1301
|
};
|
|
1302
|
+
export type GetJobApplicationInterviewRoundsQueryVariables = Types.Exact<{
|
|
1303
|
+
applicationId: Types.Scalars['ID']['input'];
|
|
1304
|
+
}>;
|
|
1305
|
+
export type GetJobApplicationInterviewRoundsQuery = {
|
|
1306
|
+
__typename?: 'Query';
|
|
1307
|
+
jobApplicationInterviewRounds: Array<{
|
|
1308
|
+
__typename?: 'InterviewRound';
|
|
1309
|
+
id: string;
|
|
1310
|
+
applicationId: string;
|
|
1311
|
+
roundConfigId?: string | null;
|
|
1312
|
+
name: string;
|
|
1313
|
+
roundType: Types.InterviewRoundType;
|
|
1314
|
+
status: Types.InterviewRoundStatus;
|
|
1315
|
+
scheduledAt?: string | null;
|
|
1316
|
+
notes?: string | null;
|
|
1317
|
+
candidateMessage?: string | null;
|
|
1318
|
+
candidateMessageSentAt?: string | null;
|
|
1319
|
+
submittedRepoUrl?: string | null;
|
|
1320
|
+
submittedVideoUrl?: string | null;
|
|
1321
|
+
submittedAt?: string | null;
|
|
1322
|
+
submittedNotes?: string | null;
|
|
1323
|
+
context?: Record<string, unknown> | null;
|
|
1324
|
+
createdAt: string;
|
|
1325
|
+
updatedAt: string;
|
|
1326
|
+
createdBy: string;
|
|
1327
|
+
onBehalfOf: string;
|
|
1328
|
+
updatedBy?: string | null;
|
|
1329
|
+
roundConfig?: {
|
|
1330
|
+
__typename?: 'InterviewRoundConfig';
|
|
1331
|
+
id: string;
|
|
1332
|
+
isAssignmentRound: boolean;
|
|
1333
|
+
} | null;
|
|
1334
|
+
interviewers: Array<{
|
|
1335
|
+
__typename?: 'InterviewRoundInterviewer';
|
|
1336
|
+
id: string;
|
|
1337
|
+
role: Types.InterviewerRole;
|
|
1338
|
+
assignedAt: string;
|
|
1339
|
+
interviewer: {
|
|
1340
|
+
__typename?: 'Interviewer';
|
|
1341
|
+
id: string;
|
|
1342
|
+
name: string;
|
|
1343
|
+
email: string;
|
|
1344
|
+
title?: string | null;
|
|
1345
|
+
};
|
|
1346
|
+
}>;
|
|
1347
|
+
feedback: Array<{
|
|
1348
|
+
__typename?: 'InterviewFeedback';
|
|
1349
|
+
id: string;
|
|
1350
|
+
interviewerId: string;
|
|
1351
|
+
rating?: number | null;
|
|
1352
|
+
verdict?: Types.InterviewVerdict | null;
|
|
1353
|
+
internalNotes?: string | null;
|
|
1354
|
+
createdAt: string;
|
|
1355
|
+
interviewer: {
|
|
1356
|
+
__typename?: 'Interviewer';
|
|
1357
|
+
id: string;
|
|
1358
|
+
name: string;
|
|
1359
|
+
};
|
|
1360
|
+
}>;
|
|
1361
|
+
assignment?: {
|
|
1362
|
+
__typename?: 'JobAssignment';
|
|
1363
|
+
id: string;
|
|
1364
|
+
title: string;
|
|
1365
|
+
description: string;
|
|
1366
|
+
} | null;
|
|
1367
|
+
}>;
|
|
1368
|
+
};
|
|
736
1369
|
export type GetJobApplicationResumeUrlQueryVariables = Types.Exact<{
|
|
737
1370
|
id: Types.Scalars['ID']['input'];
|
|
738
1371
|
}>;
|
|
@@ -761,11 +1394,116 @@ export type GetJobApplicationsQuery = {
|
|
|
761
1394
|
department?: string | null;
|
|
762
1395
|
resumeFileName?: string | null;
|
|
763
1396
|
productId?: string | null;
|
|
1397
|
+
jobPostingId?: string | null;
|
|
764
1398
|
status: Types.JobApplicationStatus;
|
|
765
1399
|
createdAt: string;
|
|
766
1400
|
}>;
|
|
767
1401
|
};
|
|
768
1402
|
};
|
|
1403
|
+
export type GetJobAssignmentsQueryVariables = Types.Exact<{
|
|
1404
|
+
filter?: Types.InputMaybe<Types.JobAssignmentFilterInput>;
|
|
1405
|
+
limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
|
|
1406
|
+
offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
|
|
1407
|
+
}>;
|
|
1408
|
+
export type GetJobAssignmentsQuery = {
|
|
1409
|
+
__typename?: 'Query';
|
|
1410
|
+
jobAssignments: {
|
|
1411
|
+
__typename?: 'JobAssignmentList';
|
|
1412
|
+
total: number;
|
|
1413
|
+
hasMore: boolean;
|
|
1414
|
+
items: Array<{
|
|
1415
|
+
__typename?: 'JobAssignment';
|
|
1416
|
+
id: string;
|
|
1417
|
+
jobPostingId: string;
|
|
1418
|
+
title: string;
|
|
1419
|
+
description: string;
|
|
1420
|
+
problemStatement?: string | null;
|
|
1421
|
+
difficulty?: string | null;
|
|
1422
|
+
isActive: boolean;
|
|
1423
|
+
}>;
|
|
1424
|
+
};
|
|
1425
|
+
};
|
|
1426
|
+
export type GetJobPostingQueryVariables = Types.Exact<{
|
|
1427
|
+
id: Types.Scalars['ID']['input'];
|
|
1428
|
+
}>;
|
|
1429
|
+
export type GetJobPostingQuery = {
|
|
1430
|
+
__typename?: 'Query';
|
|
1431
|
+
jobPosting?: {
|
|
1432
|
+
__typename?: 'JobPosting';
|
|
1433
|
+
id: string;
|
|
1434
|
+
title: string;
|
|
1435
|
+
department?: string | null;
|
|
1436
|
+
location?: string | null;
|
|
1437
|
+
employmentType?: Types.EmploymentType | null;
|
|
1438
|
+
description?: string | null;
|
|
1439
|
+
productId?: string | null;
|
|
1440
|
+
status: Types.JobPostingStatus;
|
|
1441
|
+
context?: Record<string, unknown> | null;
|
|
1442
|
+
createdAt: string;
|
|
1443
|
+
updatedAt: string;
|
|
1444
|
+
createdBy: string;
|
|
1445
|
+
onBehalfOf: string;
|
|
1446
|
+
updatedBy?: string | null;
|
|
1447
|
+
rounds: Array<{
|
|
1448
|
+
__typename?: 'InterviewRoundConfig';
|
|
1449
|
+
id: string;
|
|
1450
|
+
roundNumber: number;
|
|
1451
|
+
name: string;
|
|
1452
|
+
description?: string | null;
|
|
1453
|
+
roundType: Types.InterviewRoundType;
|
|
1454
|
+
isAssignmentRound: boolean;
|
|
1455
|
+
isRequired: boolean;
|
|
1456
|
+
}>;
|
|
1457
|
+
assignments: Array<{
|
|
1458
|
+
__typename?: 'JobAssignment';
|
|
1459
|
+
id: string;
|
|
1460
|
+
title: string;
|
|
1461
|
+
description: string;
|
|
1462
|
+
problemStatement?: string | null;
|
|
1463
|
+
difficulty?: string | null;
|
|
1464
|
+
isActive: boolean;
|
|
1465
|
+
}>;
|
|
1466
|
+
applications: Array<{
|
|
1467
|
+
__typename?: 'JobApplication';
|
|
1468
|
+
id: string;
|
|
1469
|
+
firstName: string;
|
|
1470
|
+
lastName: string;
|
|
1471
|
+
email: string;
|
|
1472
|
+
status: Types.JobApplicationStatus;
|
|
1473
|
+
createdAt: string;
|
|
1474
|
+
}>;
|
|
1475
|
+
} | null;
|
|
1476
|
+
};
|
|
1477
|
+
export type GetJobPostingsQueryVariables = Types.Exact<{
|
|
1478
|
+
filter?: Types.InputMaybe<Types.JobPostingFilterInput>;
|
|
1479
|
+
limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
|
|
1480
|
+
offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
|
|
1481
|
+
}>;
|
|
1482
|
+
export type GetJobPostingsQuery = {
|
|
1483
|
+
__typename?: 'Query';
|
|
1484
|
+
jobPostings: {
|
|
1485
|
+
__typename?: 'JobPostingList';
|
|
1486
|
+
total: number;
|
|
1487
|
+
hasMore: boolean;
|
|
1488
|
+
items: Array<{
|
|
1489
|
+
__typename?: 'JobPosting';
|
|
1490
|
+
id: string;
|
|
1491
|
+
title: string;
|
|
1492
|
+
department?: string | null;
|
|
1493
|
+
location?: string | null;
|
|
1494
|
+
employmentType?: Types.EmploymentType | null;
|
|
1495
|
+
status: Types.JobPostingStatus;
|
|
1496
|
+
description?: string | null;
|
|
1497
|
+
productId?: string | null;
|
|
1498
|
+
createdAt: string;
|
|
1499
|
+
updatedAt: string;
|
|
1500
|
+
applications: Array<{
|
|
1501
|
+
__typename?: 'JobApplication';
|
|
1502
|
+
id: string;
|
|
1503
|
+
}>;
|
|
1504
|
+
}>;
|
|
1505
|
+
};
|
|
1506
|
+
};
|
|
769
1507
|
export type GetMyTicketsQueryVariables = Types.Exact<{
|
|
770
1508
|
filter?: Types.InputMaybe<Types.SupportTicketFilterInput>;
|
|
771
1509
|
limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
|
|
@@ -1410,6 +2148,29 @@ export declare function useCreateSupportMessageMutation(baseOptions?: ApolloReac
|
|
|
1410
2148
|
export type CreateSupportMessageMutationHookResult = ReturnType<typeof useCreateSupportMessageMutation>;
|
|
1411
2149
|
export type CreateSupportMessageMutationResult = Apollo.MutationResult<Types.CreateSupportMessageMutation>;
|
|
1412
2150
|
export type CreateSupportMessageMutationOptions = Apollo.BaseMutationOptions<Types.CreateSupportMessageMutation, Types.CreateSupportMessageMutationVariables>;
|
|
2151
|
+
export declare const AssignInterviewersToRoundDocument: Apollo.DocumentNode;
|
|
2152
|
+
export type AssignInterviewersToRoundMutationFn = Apollo.MutationFunction<Types.AssignInterviewersToRoundMutation, Types.AssignInterviewersToRoundMutationVariables>;
|
|
2153
|
+
/**
|
|
2154
|
+
* __useAssignInterviewersToRoundMutation__
|
|
2155
|
+
*
|
|
2156
|
+
* To run a mutation, you first call `useAssignInterviewersToRoundMutation` within a React component and pass it any options that fit your needs.
|
|
2157
|
+
* When your component renders, `useAssignInterviewersToRoundMutation` returns a tuple that includes:
|
|
2158
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2159
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2160
|
+
*
|
|
2161
|
+
* @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;
|
|
2162
|
+
*
|
|
2163
|
+
* @example
|
|
2164
|
+
* const [assignInterviewersToRoundMutation, { data, loading, error }] = useAssignInterviewersToRoundMutation({
|
|
2165
|
+
* variables: {
|
|
2166
|
+
* input: // value for 'input'
|
|
2167
|
+
* },
|
|
2168
|
+
* });
|
|
2169
|
+
*/
|
|
2170
|
+
export declare function useAssignInterviewersToRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignInterviewersToRoundMutation, Types.AssignInterviewersToRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AssignInterviewersToRoundMutation, any, Apollo.ApolloCache, undefined>;
|
|
2171
|
+
export type AssignInterviewersToRoundMutationHookResult = ReturnType<typeof useAssignInterviewersToRoundMutation>;
|
|
2172
|
+
export type AssignInterviewersToRoundMutationResult = Apollo.MutationResult<Types.AssignInterviewersToRoundMutation>;
|
|
2173
|
+
export type AssignInterviewersToRoundMutationOptions = Apollo.BaseMutationOptions<Types.AssignInterviewersToRoundMutation, Types.AssignInterviewersToRoundMutationVariables>;
|
|
1413
2174
|
export declare const AssignSupportTicketDocument: Apollo.DocumentNode;
|
|
1414
2175
|
export type AssignSupportTicketMutationFn = Apollo.MutationFunction<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>;
|
|
1415
2176
|
/**
|
|
@@ -1504,6 +2265,121 @@ export declare function useCreateCannedResponseMutation(baseOptions?: ApolloReac
|
|
|
1504
2265
|
export type CreateCannedResponseMutationHookResult = ReturnType<typeof useCreateCannedResponseMutation>;
|
|
1505
2266
|
export type CreateCannedResponseMutationResult = Apollo.MutationResult<Types.CreateCannedResponseMutation>;
|
|
1506
2267
|
export type CreateCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.CreateCannedResponseMutation, Types.CreateCannedResponseMutationVariables>;
|
|
2268
|
+
export declare const CreateInterviewRoundDocument: Apollo.DocumentNode;
|
|
2269
|
+
export type CreateInterviewRoundMutationFn = Apollo.MutationFunction<Types.CreateInterviewRoundMutation, Types.CreateInterviewRoundMutationVariables>;
|
|
2270
|
+
/**
|
|
2271
|
+
* __useCreateInterviewRoundMutation__
|
|
2272
|
+
*
|
|
2273
|
+
* To run a mutation, you first call `useCreateInterviewRoundMutation` within a React component and pass it any options that fit your needs.
|
|
2274
|
+
* When your component renders, `useCreateInterviewRoundMutation` returns a tuple that includes:
|
|
2275
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2276
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2277
|
+
*
|
|
2278
|
+
* @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;
|
|
2279
|
+
*
|
|
2280
|
+
* @example
|
|
2281
|
+
* const [createInterviewRoundMutation, { data, loading, error }] = useCreateInterviewRoundMutation({
|
|
2282
|
+
* variables: {
|
|
2283
|
+
* input: // value for 'input'
|
|
2284
|
+
* },
|
|
2285
|
+
* });
|
|
2286
|
+
*/
|
|
2287
|
+
export declare function useCreateInterviewRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInterviewRoundMutation, Types.CreateInterviewRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateInterviewRoundMutation, any, Apollo.ApolloCache, undefined>;
|
|
2288
|
+
export type CreateInterviewRoundMutationHookResult = ReturnType<typeof useCreateInterviewRoundMutation>;
|
|
2289
|
+
export type CreateInterviewRoundMutationResult = Apollo.MutationResult<Types.CreateInterviewRoundMutation>;
|
|
2290
|
+
export type CreateInterviewRoundMutationOptions = Apollo.BaseMutationOptions<Types.CreateInterviewRoundMutation, Types.CreateInterviewRoundMutationVariables>;
|
|
2291
|
+
export declare const CreateInterviewRoundConfigDocument: Apollo.DocumentNode;
|
|
2292
|
+
export type CreateInterviewRoundConfigMutationFn = Apollo.MutationFunction<Types.CreateInterviewRoundConfigMutation, Types.CreateInterviewRoundConfigMutationVariables>;
|
|
2293
|
+
/**
|
|
2294
|
+
* __useCreateInterviewRoundConfigMutation__
|
|
2295
|
+
*
|
|
2296
|
+
* To run a mutation, you first call `useCreateInterviewRoundConfigMutation` within a React component and pass it any options that fit your needs.
|
|
2297
|
+
* When your component renders, `useCreateInterviewRoundConfigMutation` returns a tuple that includes:
|
|
2298
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2299
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2300
|
+
*
|
|
2301
|
+
* @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;
|
|
2302
|
+
*
|
|
2303
|
+
* @example
|
|
2304
|
+
* const [createInterviewRoundConfigMutation, { data, loading, error }] = useCreateInterviewRoundConfigMutation({
|
|
2305
|
+
* variables: {
|
|
2306
|
+
* input: // value for 'input'
|
|
2307
|
+
* },
|
|
2308
|
+
* });
|
|
2309
|
+
*/
|
|
2310
|
+
export declare function useCreateInterviewRoundConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInterviewRoundConfigMutation, Types.CreateInterviewRoundConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateInterviewRoundConfigMutation, any, Apollo.ApolloCache, undefined>;
|
|
2311
|
+
export type CreateInterviewRoundConfigMutationHookResult = ReturnType<typeof useCreateInterviewRoundConfigMutation>;
|
|
2312
|
+
export type CreateInterviewRoundConfigMutationResult = Apollo.MutationResult<Types.CreateInterviewRoundConfigMutation>;
|
|
2313
|
+
export type CreateInterviewRoundConfigMutationOptions = Apollo.BaseMutationOptions<Types.CreateInterviewRoundConfigMutation, Types.CreateInterviewRoundConfigMutationVariables>;
|
|
2314
|
+
export declare const CreateInterviewerDocument: Apollo.DocumentNode;
|
|
2315
|
+
export type CreateInterviewerMutationFn = Apollo.MutationFunction<Types.CreateInterviewerMutation, Types.CreateInterviewerMutationVariables>;
|
|
2316
|
+
/**
|
|
2317
|
+
* __useCreateInterviewerMutation__
|
|
2318
|
+
*
|
|
2319
|
+
* To run a mutation, you first call `useCreateInterviewerMutation` within a React component and pass it any options that fit your needs.
|
|
2320
|
+
* When your component renders, `useCreateInterviewerMutation` returns a tuple that includes:
|
|
2321
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2322
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2323
|
+
*
|
|
2324
|
+
* @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;
|
|
2325
|
+
*
|
|
2326
|
+
* @example
|
|
2327
|
+
* const [createInterviewerMutation, { data, loading, error }] = useCreateInterviewerMutation({
|
|
2328
|
+
* variables: {
|
|
2329
|
+
* input: // value for 'input'
|
|
2330
|
+
* },
|
|
2331
|
+
* });
|
|
2332
|
+
*/
|
|
2333
|
+
export declare function useCreateInterviewerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateInterviewerMutation, Types.CreateInterviewerMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateInterviewerMutation, any, Apollo.ApolloCache, undefined>;
|
|
2334
|
+
export type CreateInterviewerMutationHookResult = ReturnType<typeof useCreateInterviewerMutation>;
|
|
2335
|
+
export type CreateInterviewerMutationResult = Apollo.MutationResult<Types.CreateInterviewerMutation>;
|
|
2336
|
+
export type CreateInterviewerMutationOptions = Apollo.BaseMutationOptions<Types.CreateInterviewerMutation, Types.CreateInterviewerMutationVariables>;
|
|
2337
|
+
export declare const CreateJobAssignmentDocument: Apollo.DocumentNode;
|
|
2338
|
+
export type CreateJobAssignmentMutationFn = Apollo.MutationFunction<Types.CreateJobAssignmentMutation, Types.CreateJobAssignmentMutationVariables>;
|
|
2339
|
+
/**
|
|
2340
|
+
* __useCreateJobAssignmentMutation__
|
|
2341
|
+
*
|
|
2342
|
+
* To run a mutation, you first call `useCreateJobAssignmentMutation` within a React component and pass it any options that fit your needs.
|
|
2343
|
+
* When your component renders, `useCreateJobAssignmentMutation` returns a tuple that includes:
|
|
2344
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2345
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2346
|
+
*
|
|
2347
|
+
* @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;
|
|
2348
|
+
*
|
|
2349
|
+
* @example
|
|
2350
|
+
* const [createJobAssignmentMutation, { data, loading, error }] = useCreateJobAssignmentMutation({
|
|
2351
|
+
* variables: {
|
|
2352
|
+
* input: // value for 'input'
|
|
2353
|
+
* },
|
|
2354
|
+
* });
|
|
2355
|
+
*/
|
|
2356
|
+
export declare function useCreateJobAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateJobAssignmentMutation, Types.CreateJobAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateJobAssignmentMutation, any, Apollo.ApolloCache, undefined>;
|
|
2357
|
+
export type CreateJobAssignmentMutationHookResult = ReturnType<typeof useCreateJobAssignmentMutation>;
|
|
2358
|
+
export type CreateJobAssignmentMutationResult = Apollo.MutationResult<Types.CreateJobAssignmentMutation>;
|
|
2359
|
+
export type CreateJobAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.CreateJobAssignmentMutation, Types.CreateJobAssignmentMutationVariables>;
|
|
2360
|
+
export declare const CreateJobPostingDocument: Apollo.DocumentNode;
|
|
2361
|
+
export type CreateJobPostingMutationFn = Apollo.MutationFunction<Types.CreateJobPostingMutation, Types.CreateJobPostingMutationVariables>;
|
|
2362
|
+
/**
|
|
2363
|
+
* __useCreateJobPostingMutation__
|
|
2364
|
+
*
|
|
2365
|
+
* To run a mutation, you first call `useCreateJobPostingMutation` within a React component and pass it any options that fit your needs.
|
|
2366
|
+
* When your component renders, `useCreateJobPostingMutation` returns a tuple that includes:
|
|
2367
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2368
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2369
|
+
*
|
|
2370
|
+
* @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;
|
|
2371
|
+
*
|
|
2372
|
+
* @example
|
|
2373
|
+
* const [createJobPostingMutation, { data, loading, error }] = useCreateJobPostingMutation({
|
|
2374
|
+
* variables: {
|
|
2375
|
+
* input: // value for 'input'
|
|
2376
|
+
* },
|
|
2377
|
+
* });
|
|
2378
|
+
*/
|
|
2379
|
+
export declare function useCreateJobPostingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateJobPostingMutation, Types.CreateJobPostingMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateJobPostingMutation, any, Apollo.ApolloCache, undefined>;
|
|
2380
|
+
export type CreateJobPostingMutationHookResult = ReturnType<typeof useCreateJobPostingMutation>;
|
|
2381
|
+
export type CreateJobPostingMutationResult = Apollo.MutationResult<Types.CreateJobPostingMutation>;
|
|
2382
|
+
export type CreateJobPostingMutationOptions = Apollo.BaseMutationOptions<Types.CreateJobPostingMutation, Types.CreateJobPostingMutationVariables>;
|
|
1507
2383
|
export declare const CreateSlaPolicyDocument: Apollo.DocumentNode;
|
|
1508
2384
|
export type CreateSlaPolicyMutationFn = Apollo.MutationFunction<Types.CreateSlaPolicyMutation, Types.CreateSlaPolicyMutationVariables>;
|
|
1509
2385
|
/**
|
|
@@ -1530,49 +2406,187 @@ export type CreateSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.Cr
|
|
|
1530
2406
|
export declare const CreateSupportTicketDocument: Apollo.DocumentNode;
|
|
1531
2407
|
export type CreateSupportTicketMutationFn = Apollo.MutationFunction<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>;
|
|
1532
2408
|
/**
|
|
1533
|
-
* __useCreateSupportTicketMutation__
|
|
2409
|
+
* __useCreateSupportTicketMutation__
|
|
2410
|
+
*
|
|
2411
|
+
* To run a mutation, you first call `useCreateSupportTicketMutation` within a React component and pass it any options that fit your needs.
|
|
2412
|
+
* When your component renders, `useCreateSupportTicketMutation` returns a tuple that includes:
|
|
2413
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2414
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2415
|
+
*
|
|
2416
|
+
* @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;
|
|
2417
|
+
*
|
|
2418
|
+
* @example
|
|
2419
|
+
* const [createSupportTicketMutation, { data, loading, error }] = useCreateSupportTicketMutation({
|
|
2420
|
+
* variables: {
|
|
2421
|
+
* input: // value for 'input'
|
|
2422
|
+
* },
|
|
2423
|
+
* });
|
|
2424
|
+
*/
|
|
2425
|
+
export declare function useCreateSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
|
|
2426
|
+
export type CreateSupportTicketMutationHookResult = ReturnType<typeof useCreateSupportTicketMutation>;
|
|
2427
|
+
export type CreateSupportTicketMutationResult = Apollo.MutationResult<Types.CreateSupportTicketMutation>;
|
|
2428
|
+
export type CreateSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>;
|
|
2429
|
+
export declare const DeleteCannedResponseDocument: Apollo.DocumentNode;
|
|
2430
|
+
export type DeleteCannedResponseMutationFn = Apollo.MutationFunction<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>;
|
|
2431
|
+
/**
|
|
2432
|
+
* __useDeleteCannedResponseMutation__
|
|
2433
|
+
*
|
|
2434
|
+
* To run a mutation, you first call `useDeleteCannedResponseMutation` within a React component and pass it any options that fit your needs.
|
|
2435
|
+
* When your component renders, `useDeleteCannedResponseMutation` returns a tuple that includes:
|
|
2436
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2437
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2438
|
+
*
|
|
2439
|
+
* @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;
|
|
2440
|
+
*
|
|
2441
|
+
* @example
|
|
2442
|
+
* const [deleteCannedResponseMutation, { data, loading, error }] = useDeleteCannedResponseMutation({
|
|
2443
|
+
* variables: {
|
|
2444
|
+
* id: // value for 'id'
|
|
2445
|
+
* },
|
|
2446
|
+
* });
|
|
2447
|
+
*/
|
|
2448
|
+
export declare function useDeleteCannedResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteCannedResponseMutation, any, Apollo.ApolloCache, undefined>;
|
|
2449
|
+
export type DeleteCannedResponseMutationHookResult = ReturnType<typeof useDeleteCannedResponseMutation>;
|
|
2450
|
+
export type DeleteCannedResponseMutationResult = Apollo.MutationResult<Types.DeleteCannedResponseMutation>;
|
|
2451
|
+
export type DeleteCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>;
|
|
2452
|
+
export declare const DeleteInterviewFeedbackDocument: Apollo.DocumentNode;
|
|
2453
|
+
export type DeleteInterviewFeedbackMutationFn = Apollo.MutationFunction<Types.DeleteInterviewFeedbackMutation, Types.DeleteInterviewFeedbackMutationVariables>;
|
|
2454
|
+
/**
|
|
2455
|
+
* __useDeleteInterviewFeedbackMutation__
|
|
2456
|
+
*
|
|
2457
|
+
* To run a mutation, you first call `useDeleteInterviewFeedbackMutation` within a React component and pass it any options that fit your needs.
|
|
2458
|
+
* When your component renders, `useDeleteInterviewFeedbackMutation` returns a tuple that includes:
|
|
2459
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2460
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2461
|
+
*
|
|
2462
|
+
* @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;
|
|
2463
|
+
*
|
|
2464
|
+
* @example
|
|
2465
|
+
* const [deleteInterviewFeedbackMutation, { data, loading, error }] = useDeleteInterviewFeedbackMutation({
|
|
2466
|
+
* variables: {
|
|
2467
|
+
* id: // value for 'id'
|
|
2468
|
+
* },
|
|
2469
|
+
* });
|
|
2470
|
+
*/
|
|
2471
|
+
export declare function useDeleteInterviewFeedbackMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewFeedbackMutation, Types.DeleteInterviewFeedbackMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewFeedbackMutation, any, Apollo.ApolloCache, undefined>;
|
|
2472
|
+
export type DeleteInterviewFeedbackMutationHookResult = ReturnType<typeof useDeleteInterviewFeedbackMutation>;
|
|
2473
|
+
export type DeleteInterviewFeedbackMutationResult = Apollo.MutationResult<Types.DeleteInterviewFeedbackMutation>;
|
|
2474
|
+
export type DeleteInterviewFeedbackMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewFeedbackMutation, Types.DeleteInterviewFeedbackMutationVariables>;
|
|
2475
|
+
export declare const DeleteInterviewRoundDocument: Apollo.DocumentNode;
|
|
2476
|
+
export type DeleteInterviewRoundMutationFn = Apollo.MutationFunction<Types.DeleteInterviewRoundMutation, Types.DeleteInterviewRoundMutationVariables>;
|
|
2477
|
+
/**
|
|
2478
|
+
* __useDeleteInterviewRoundMutation__
|
|
2479
|
+
*
|
|
2480
|
+
* To run a mutation, you first call `useDeleteInterviewRoundMutation` within a React component and pass it any options that fit your needs.
|
|
2481
|
+
* When your component renders, `useDeleteInterviewRoundMutation` returns a tuple that includes:
|
|
2482
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2483
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2484
|
+
*
|
|
2485
|
+
* @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;
|
|
2486
|
+
*
|
|
2487
|
+
* @example
|
|
2488
|
+
* const [deleteInterviewRoundMutation, { data, loading, error }] = useDeleteInterviewRoundMutation({
|
|
2489
|
+
* variables: {
|
|
2490
|
+
* id: // value for 'id'
|
|
2491
|
+
* },
|
|
2492
|
+
* });
|
|
2493
|
+
*/
|
|
2494
|
+
export declare function useDeleteInterviewRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewRoundMutation, Types.DeleteInterviewRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewRoundMutation, any, Apollo.ApolloCache, undefined>;
|
|
2495
|
+
export type DeleteInterviewRoundMutationHookResult = ReturnType<typeof useDeleteInterviewRoundMutation>;
|
|
2496
|
+
export type DeleteInterviewRoundMutationResult = Apollo.MutationResult<Types.DeleteInterviewRoundMutation>;
|
|
2497
|
+
export type DeleteInterviewRoundMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewRoundMutation, Types.DeleteInterviewRoundMutationVariables>;
|
|
2498
|
+
export declare const DeleteInterviewRoundConfigDocument: Apollo.DocumentNode;
|
|
2499
|
+
export type DeleteInterviewRoundConfigMutationFn = Apollo.MutationFunction<Types.DeleteInterviewRoundConfigMutation, Types.DeleteInterviewRoundConfigMutationVariables>;
|
|
2500
|
+
/**
|
|
2501
|
+
* __useDeleteInterviewRoundConfigMutation__
|
|
2502
|
+
*
|
|
2503
|
+
* To run a mutation, you first call `useDeleteInterviewRoundConfigMutation` within a React component and pass it any options that fit your needs.
|
|
2504
|
+
* When your component renders, `useDeleteInterviewRoundConfigMutation` returns a tuple that includes:
|
|
2505
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2506
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2507
|
+
*
|
|
2508
|
+
* @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;
|
|
2509
|
+
*
|
|
2510
|
+
* @example
|
|
2511
|
+
* const [deleteInterviewRoundConfigMutation, { data, loading, error }] = useDeleteInterviewRoundConfigMutation({
|
|
2512
|
+
* variables: {
|
|
2513
|
+
* id: // value for 'id'
|
|
2514
|
+
* },
|
|
2515
|
+
* });
|
|
2516
|
+
*/
|
|
2517
|
+
export declare function useDeleteInterviewRoundConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewRoundConfigMutation, Types.DeleteInterviewRoundConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewRoundConfigMutation, any, Apollo.ApolloCache, undefined>;
|
|
2518
|
+
export type DeleteInterviewRoundConfigMutationHookResult = ReturnType<typeof useDeleteInterviewRoundConfigMutation>;
|
|
2519
|
+
export type DeleteInterviewRoundConfigMutationResult = Apollo.MutationResult<Types.DeleteInterviewRoundConfigMutation>;
|
|
2520
|
+
export type DeleteInterviewRoundConfigMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewRoundConfigMutation, Types.DeleteInterviewRoundConfigMutationVariables>;
|
|
2521
|
+
export declare const DeleteInterviewerDocument: Apollo.DocumentNode;
|
|
2522
|
+
export type DeleteInterviewerMutationFn = Apollo.MutationFunction<Types.DeleteInterviewerMutation, Types.DeleteInterviewerMutationVariables>;
|
|
2523
|
+
/**
|
|
2524
|
+
* __useDeleteInterviewerMutation__
|
|
2525
|
+
*
|
|
2526
|
+
* To run a mutation, you first call `useDeleteInterviewerMutation` within a React component and pass it any options that fit your needs.
|
|
2527
|
+
* When your component renders, `useDeleteInterviewerMutation` returns a tuple that includes:
|
|
2528
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2529
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2530
|
+
*
|
|
2531
|
+
* @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;
|
|
2532
|
+
*
|
|
2533
|
+
* @example
|
|
2534
|
+
* const [deleteInterviewerMutation, { data, loading, error }] = useDeleteInterviewerMutation({
|
|
2535
|
+
* variables: {
|
|
2536
|
+
* id: // value for 'id'
|
|
2537
|
+
* },
|
|
2538
|
+
* });
|
|
2539
|
+
*/
|
|
2540
|
+
export declare function useDeleteInterviewerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteInterviewerMutation, Types.DeleteInterviewerMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteInterviewerMutation, any, Apollo.ApolloCache, undefined>;
|
|
2541
|
+
export type DeleteInterviewerMutationHookResult = ReturnType<typeof useDeleteInterviewerMutation>;
|
|
2542
|
+
export type DeleteInterviewerMutationResult = Apollo.MutationResult<Types.DeleteInterviewerMutation>;
|
|
2543
|
+
export type DeleteInterviewerMutationOptions = Apollo.BaseMutationOptions<Types.DeleteInterviewerMutation, Types.DeleteInterviewerMutationVariables>;
|
|
2544
|
+
export declare const DeleteJobAssignmentDocument: Apollo.DocumentNode;
|
|
2545
|
+
export type DeleteJobAssignmentMutationFn = Apollo.MutationFunction<Types.DeleteJobAssignmentMutation, Types.DeleteJobAssignmentMutationVariables>;
|
|
2546
|
+
/**
|
|
2547
|
+
* __useDeleteJobAssignmentMutation__
|
|
1534
2548
|
*
|
|
1535
|
-
* To run a mutation, you first call `
|
|
1536
|
-
* When your component renders, `
|
|
2549
|
+
* To run a mutation, you first call `useDeleteJobAssignmentMutation` within a React component and pass it any options that fit your needs.
|
|
2550
|
+
* When your component renders, `useDeleteJobAssignmentMutation` returns a tuple that includes:
|
|
1537
2551
|
* - A mutate function that you can call at any time to execute the mutation
|
|
1538
2552
|
* - An object with fields that represent the current status of the mutation's execution
|
|
1539
2553
|
*
|
|
1540
2554
|
* @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;
|
|
1541
2555
|
*
|
|
1542
2556
|
* @example
|
|
1543
|
-
* const [
|
|
2557
|
+
* const [deleteJobAssignmentMutation, { data, loading, error }] = useDeleteJobAssignmentMutation({
|
|
1544
2558
|
* variables: {
|
|
1545
|
-
*
|
|
2559
|
+
* id: // value for 'id'
|
|
1546
2560
|
* },
|
|
1547
2561
|
* });
|
|
1548
2562
|
*/
|
|
1549
|
-
export declare function
|
|
1550
|
-
export type
|
|
1551
|
-
export type
|
|
1552
|
-
export type
|
|
1553
|
-
export declare const
|
|
1554
|
-
export type
|
|
2563
|
+
export declare function useDeleteJobAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteJobAssignmentMutation, Types.DeleteJobAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteJobAssignmentMutation, any, Apollo.ApolloCache, undefined>;
|
|
2564
|
+
export type DeleteJobAssignmentMutationHookResult = ReturnType<typeof useDeleteJobAssignmentMutation>;
|
|
2565
|
+
export type DeleteJobAssignmentMutationResult = Apollo.MutationResult<Types.DeleteJobAssignmentMutation>;
|
|
2566
|
+
export type DeleteJobAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.DeleteJobAssignmentMutation, Types.DeleteJobAssignmentMutationVariables>;
|
|
2567
|
+
export declare const DeleteJobPostingDocument: Apollo.DocumentNode;
|
|
2568
|
+
export type DeleteJobPostingMutationFn = Apollo.MutationFunction<Types.DeleteJobPostingMutation, Types.DeleteJobPostingMutationVariables>;
|
|
1555
2569
|
/**
|
|
1556
|
-
*
|
|
2570
|
+
* __useDeleteJobPostingMutation__
|
|
1557
2571
|
*
|
|
1558
|
-
* To run a mutation, you first call `
|
|
1559
|
-
* When your component renders, `
|
|
2572
|
+
* To run a mutation, you first call `useDeleteJobPostingMutation` within a React component and pass it any options that fit your needs.
|
|
2573
|
+
* When your component renders, `useDeleteJobPostingMutation` returns a tuple that includes:
|
|
1560
2574
|
* - A mutate function that you can call at any time to execute the mutation
|
|
1561
2575
|
* - An object with fields that represent the current status of the mutation's execution
|
|
1562
2576
|
*
|
|
1563
2577
|
* @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;
|
|
1564
2578
|
*
|
|
1565
2579
|
* @example
|
|
1566
|
-
* const [
|
|
2580
|
+
* const [deleteJobPostingMutation, { data, loading, error }] = useDeleteJobPostingMutation({
|
|
1567
2581
|
* variables: {
|
|
1568
2582
|
* id: // value for 'id'
|
|
1569
2583
|
* },
|
|
1570
2584
|
* });
|
|
1571
2585
|
*/
|
|
1572
|
-
export declare function
|
|
1573
|
-
export type
|
|
1574
|
-
export type
|
|
1575
|
-
export type
|
|
2586
|
+
export declare function useDeleteJobPostingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteJobPostingMutation, Types.DeleteJobPostingMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteJobPostingMutation, any, Apollo.ApolloCache, undefined>;
|
|
2587
|
+
export type DeleteJobPostingMutationHookResult = ReturnType<typeof useDeleteJobPostingMutation>;
|
|
2588
|
+
export type DeleteJobPostingMutationResult = Apollo.MutationResult<Types.DeleteJobPostingMutation>;
|
|
2589
|
+
export type DeleteJobPostingMutationOptions = Apollo.BaseMutationOptions<Types.DeleteJobPostingMutation, Types.DeleteJobPostingMutationVariables>;
|
|
1576
2590
|
export declare const DeleteSlaPolicyDocument: Apollo.DocumentNode;
|
|
1577
2591
|
export type DeleteSlaPolicyMutationFn = Apollo.MutationFunction<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>;
|
|
1578
2592
|
/**
|
|
@@ -1596,6 +2610,29 @@ export declare function useDeleteSlaPolicyMutation(baseOptions?: ApolloReactHook
|
|
|
1596
2610
|
export type DeleteSlaPolicyMutationHookResult = ReturnType<typeof useDeleteSlaPolicyMutation>;
|
|
1597
2611
|
export type DeleteSlaPolicyMutationResult = Apollo.MutationResult<Types.DeleteSlaPolicyMutation>;
|
|
1598
2612
|
export type DeleteSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>;
|
|
2613
|
+
export declare const RandomizeAndSendAssignmentDocument: Apollo.DocumentNode;
|
|
2614
|
+
export type RandomizeAndSendAssignmentMutationFn = Apollo.MutationFunction<Types.RandomizeAndSendAssignmentMutation, Types.RandomizeAndSendAssignmentMutationVariables>;
|
|
2615
|
+
/**
|
|
2616
|
+
* __useRandomizeAndSendAssignmentMutation__
|
|
2617
|
+
*
|
|
2618
|
+
* To run a mutation, you first call `useRandomizeAndSendAssignmentMutation` within a React component and pass it any options that fit your needs.
|
|
2619
|
+
* When your component renders, `useRandomizeAndSendAssignmentMutation` returns a tuple that includes:
|
|
2620
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2621
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2622
|
+
*
|
|
2623
|
+
* @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;
|
|
2624
|
+
*
|
|
2625
|
+
* @example
|
|
2626
|
+
* const [randomizeAndSendAssignmentMutation, { data, loading, error }] = useRandomizeAndSendAssignmentMutation({
|
|
2627
|
+
* variables: {
|
|
2628
|
+
* input: // value for 'input'
|
|
2629
|
+
* },
|
|
2630
|
+
* });
|
|
2631
|
+
*/
|
|
2632
|
+
export declare function useRandomizeAndSendAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RandomizeAndSendAssignmentMutation, Types.RandomizeAndSendAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RandomizeAndSendAssignmentMutation, any, Apollo.ApolloCache, undefined>;
|
|
2633
|
+
export type RandomizeAndSendAssignmentMutationHookResult = ReturnType<typeof useRandomizeAndSendAssignmentMutation>;
|
|
2634
|
+
export type RandomizeAndSendAssignmentMutationResult = Apollo.MutationResult<Types.RandomizeAndSendAssignmentMutation>;
|
|
2635
|
+
export type RandomizeAndSendAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.RandomizeAndSendAssignmentMutation, Types.RandomizeAndSendAssignmentMutationVariables>;
|
|
1599
2636
|
export declare const RateArticleDocument: Apollo.DocumentNode;
|
|
1600
2637
|
export type RateArticleMutationFn = Apollo.MutationFunction<Types.RateArticleMutation, Types.RateArticleMutationVariables>;
|
|
1601
2638
|
/**
|
|
@@ -1643,6 +2680,53 @@ export declare function useRecordArticleViewMutation(baseOptions?: ApolloReactHo
|
|
|
1643
2680
|
export type RecordArticleViewMutationHookResult = ReturnType<typeof useRecordArticleViewMutation>;
|
|
1644
2681
|
export type RecordArticleViewMutationResult = Apollo.MutationResult<Types.RecordArticleViewMutation>;
|
|
1645
2682
|
export type RecordArticleViewMutationOptions = Apollo.BaseMutationOptions<Types.RecordArticleViewMutation, Types.RecordArticleViewMutationVariables>;
|
|
2683
|
+
export declare const RecordAssignmentSubmissionDocument: Apollo.DocumentNode;
|
|
2684
|
+
export type RecordAssignmentSubmissionMutationFn = Apollo.MutationFunction<Types.RecordAssignmentSubmissionMutation, Types.RecordAssignmentSubmissionMutationVariables>;
|
|
2685
|
+
/**
|
|
2686
|
+
* __useRecordAssignmentSubmissionMutation__
|
|
2687
|
+
*
|
|
2688
|
+
* To run a mutation, you first call `useRecordAssignmentSubmissionMutation` within a React component and pass it any options that fit your needs.
|
|
2689
|
+
* When your component renders, `useRecordAssignmentSubmissionMutation` returns a tuple that includes:
|
|
2690
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2691
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2692
|
+
*
|
|
2693
|
+
* @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;
|
|
2694
|
+
*
|
|
2695
|
+
* @example
|
|
2696
|
+
* const [recordAssignmentSubmissionMutation, { data, loading, error }] = useRecordAssignmentSubmissionMutation({
|
|
2697
|
+
* variables: {
|
|
2698
|
+
* input: // value for 'input'
|
|
2699
|
+
* },
|
|
2700
|
+
* });
|
|
2701
|
+
*/
|
|
2702
|
+
export declare function useRecordAssignmentSubmissionMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RecordAssignmentSubmissionMutation, Types.RecordAssignmentSubmissionMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RecordAssignmentSubmissionMutation, any, Apollo.ApolloCache, undefined>;
|
|
2703
|
+
export type RecordAssignmentSubmissionMutationHookResult = ReturnType<typeof useRecordAssignmentSubmissionMutation>;
|
|
2704
|
+
export type RecordAssignmentSubmissionMutationResult = Apollo.MutationResult<Types.RecordAssignmentSubmissionMutation>;
|
|
2705
|
+
export type RecordAssignmentSubmissionMutationOptions = Apollo.BaseMutationOptions<Types.RecordAssignmentSubmissionMutation, Types.RecordAssignmentSubmissionMutationVariables>;
|
|
2706
|
+
export declare const RemoveInterviewerFromRoundDocument: Apollo.DocumentNode;
|
|
2707
|
+
export type RemoveInterviewerFromRoundMutationFn = Apollo.MutationFunction<Types.RemoveInterviewerFromRoundMutation, Types.RemoveInterviewerFromRoundMutationVariables>;
|
|
2708
|
+
/**
|
|
2709
|
+
* __useRemoveInterviewerFromRoundMutation__
|
|
2710
|
+
*
|
|
2711
|
+
* To run a mutation, you first call `useRemoveInterviewerFromRoundMutation` within a React component and pass it any options that fit your needs.
|
|
2712
|
+
* When your component renders, `useRemoveInterviewerFromRoundMutation` returns a tuple that includes:
|
|
2713
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2714
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2715
|
+
*
|
|
2716
|
+
* @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;
|
|
2717
|
+
*
|
|
2718
|
+
* @example
|
|
2719
|
+
* const [removeInterviewerFromRoundMutation, { data, loading, error }] = useRemoveInterviewerFromRoundMutation({
|
|
2720
|
+
* variables: {
|
|
2721
|
+
* roundId: // value for 'roundId'
|
|
2722
|
+
* interviewerId: // value for 'interviewerId'
|
|
2723
|
+
* },
|
|
2724
|
+
* });
|
|
2725
|
+
*/
|
|
2726
|
+
export declare function useRemoveInterviewerFromRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RemoveInterviewerFromRoundMutation, Types.RemoveInterviewerFromRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RemoveInterviewerFromRoundMutation, any, Apollo.ApolloCache, undefined>;
|
|
2727
|
+
export type RemoveInterviewerFromRoundMutationHookResult = ReturnType<typeof useRemoveInterviewerFromRoundMutation>;
|
|
2728
|
+
export type RemoveInterviewerFromRoundMutationResult = Apollo.MutationResult<Types.RemoveInterviewerFromRoundMutation>;
|
|
2729
|
+
export type RemoveInterviewerFromRoundMutationOptions = Apollo.BaseMutationOptions<Types.RemoveInterviewerFromRoundMutation, Types.RemoveInterviewerFromRoundMutationVariables>;
|
|
1646
2730
|
export declare const ReplyToContactInquiryDocument: Apollo.DocumentNode;
|
|
1647
2731
|
export type ReplyToContactInquiryMutationFn = Apollo.MutationFunction<Types.ReplyToContactInquiryMutation, Types.ReplyToContactInquiryMutationVariables>;
|
|
1648
2732
|
/**
|
|
@@ -1715,6 +2799,52 @@ export declare function useResolveSupportTicketMutation(baseOptions?: ApolloReac
|
|
|
1715
2799
|
export type ResolveSupportTicketMutationHookResult = ReturnType<typeof useResolveSupportTicketMutation>;
|
|
1716
2800
|
export type ResolveSupportTicketMutationResult = Apollo.MutationResult<Types.ResolveSupportTicketMutation>;
|
|
1717
2801
|
export type ResolveSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.ResolveSupportTicketMutation, Types.ResolveSupportTicketMutationVariables>;
|
|
2802
|
+
export declare const SendRoundMessageToCandidateDocument: Apollo.DocumentNode;
|
|
2803
|
+
export type SendRoundMessageToCandidateMutationFn = Apollo.MutationFunction<Types.SendRoundMessageToCandidateMutation, Types.SendRoundMessageToCandidateMutationVariables>;
|
|
2804
|
+
/**
|
|
2805
|
+
* __useSendRoundMessageToCandidateMutation__
|
|
2806
|
+
*
|
|
2807
|
+
* To run a mutation, you first call `useSendRoundMessageToCandidateMutation` within a React component and pass it any options that fit your needs.
|
|
2808
|
+
* When your component renders, `useSendRoundMessageToCandidateMutation` returns a tuple that includes:
|
|
2809
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2810
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2811
|
+
*
|
|
2812
|
+
* @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;
|
|
2813
|
+
*
|
|
2814
|
+
* @example
|
|
2815
|
+
* const [sendRoundMessageToCandidateMutation, { data, loading, error }] = useSendRoundMessageToCandidateMutation({
|
|
2816
|
+
* variables: {
|
|
2817
|
+
* input: // value for 'input'
|
|
2818
|
+
* },
|
|
2819
|
+
* });
|
|
2820
|
+
*/
|
|
2821
|
+
export declare function useSendRoundMessageToCandidateMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SendRoundMessageToCandidateMutation, Types.SendRoundMessageToCandidateMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SendRoundMessageToCandidateMutation, any, Apollo.ApolloCache, undefined>;
|
|
2822
|
+
export type SendRoundMessageToCandidateMutationHookResult = ReturnType<typeof useSendRoundMessageToCandidateMutation>;
|
|
2823
|
+
export type SendRoundMessageToCandidateMutationResult = Apollo.MutationResult<Types.SendRoundMessageToCandidateMutation>;
|
|
2824
|
+
export type SendRoundMessageToCandidateMutationOptions = Apollo.BaseMutationOptions<Types.SendRoundMessageToCandidateMutation, Types.SendRoundMessageToCandidateMutationVariables>;
|
|
2825
|
+
export declare const SubmitInterviewFeedbackDocument: Apollo.DocumentNode;
|
|
2826
|
+
export type SubmitInterviewFeedbackMutationFn = Apollo.MutationFunction<Types.SubmitInterviewFeedbackMutation, Types.SubmitInterviewFeedbackMutationVariables>;
|
|
2827
|
+
/**
|
|
2828
|
+
* __useSubmitInterviewFeedbackMutation__
|
|
2829
|
+
*
|
|
2830
|
+
* To run a mutation, you first call `useSubmitInterviewFeedbackMutation` within a React component and pass it any options that fit your needs.
|
|
2831
|
+
* When your component renders, `useSubmitInterviewFeedbackMutation` returns a tuple that includes:
|
|
2832
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2833
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2834
|
+
*
|
|
2835
|
+
* @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;
|
|
2836
|
+
*
|
|
2837
|
+
* @example
|
|
2838
|
+
* const [submitInterviewFeedbackMutation, { data, loading, error }] = useSubmitInterviewFeedbackMutation({
|
|
2839
|
+
* variables: {
|
|
2840
|
+
* input: // value for 'input'
|
|
2841
|
+
* },
|
|
2842
|
+
* });
|
|
2843
|
+
*/
|
|
2844
|
+
export declare function useSubmitInterviewFeedbackMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SubmitInterviewFeedbackMutation, Types.SubmitInterviewFeedbackMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SubmitInterviewFeedbackMutation, any, Apollo.ApolloCache, undefined>;
|
|
2845
|
+
export type SubmitInterviewFeedbackMutationHookResult = ReturnType<typeof useSubmitInterviewFeedbackMutation>;
|
|
2846
|
+
export type SubmitInterviewFeedbackMutationResult = Apollo.MutationResult<Types.SubmitInterviewFeedbackMutation>;
|
|
2847
|
+
export type SubmitInterviewFeedbackMutationOptions = Apollo.BaseMutationOptions<Types.SubmitInterviewFeedbackMutation, Types.SubmitInterviewFeedbackMutationVariables>;
|
|
1718
2848
|
export declare const SubmitSatisfactionSurveyDocument: Apollo.DocumentNode;
|
|
1719
2849
|
export type SubmitSatisfactionSurveyMutationFn = Apollo.MutationFunction<Types.SubmitSatisfactionSurveyMutation, Types.SubmitSatisfactionSurveyMutationVariables>;
|
|
1720
2850
|
/**
|
|
@@ -1786,6 +2916,102 @@ export declare function useUpdateContactInquiryStatusMutation(baseOptions?: Apol
|
|
|
1786
2916
|
export type UpdateContactInquiryStatusMutationHookResult = ReturnType<typeof useUpdateContactInquiryStatusMutation>;
|
|
1787
2917
|
export type UpdateContactInquiryStatusMutationResult = Apollo.MutationResult<Types.UpdateContactInquiryStatusMutation>;
|
|
1788
2918
|
export type UpdateContactInquiryStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateContactInquiryStatusMutation, Types.UpdateContactInquiryStatusMutationVariables>;
|
|
2919
|
+
export declare const UpdateInterviewFeedbackDocument: Apollo.DocumentNode;
|
|
2920
|
+
export type UpdateInterviewFeedbackMutationFn = Apollo.MutationFunction<Types.UpdateInterviewFeedbackMutation, Types.UpdateInterviewFeedbackMutationVariables>;
|
|
2921
|
+
/**
|
|
2922
|
+
* __useUpdateInterviewFeedbackMutation__
|
|
2923
|
+
*
|
|
2924
|
+
* To run a mutation, you first call `useUpdateInterviewFeedbackMutation` within a React component and pass it any options that fit your needs.
|
|
2925
|
+
* When your component renders, `useUpdateInterviewFeedbackMutation` returns a tuple that includes:
|
|
2926
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2927
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2928
|
+
*
|
|
2929
|
+
* @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;
|
|
2930
|
+
*
|
|
2931
|
+
* @example
|
|
2932
|
+
* const [updateInterviewFeedbackMutation, { data, loading, error }] = useUpdateInterviewFeedbackMutation({
|
|
2933
|
+
* variables: {
|
|
2934
|
+
* id: // value for 'id'
|
|
2935
|
+
* input: // value for 'input'
|
|
2936
|
+
* },
|
|
2937
|
+
* });
|
|
2938
|
+
*/
|
|
2939
|
+
export declare function useUpdateInterviewFeedbackMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewFeedbackMutation, Types.UpdateInterviewFeedbackMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewFeedbackMutation, any, Apollo.ApolloCache, undefined>;
|
|
2940
|
+
export type UpdateInterviewFeedbackMutationHookResult = ReturnType<typeof useUpdateInterviewFeedbackMutation>;
|
|
2941
|
+
export type UpdateInterviewFeedbackMutationResult = Apollo.MutationResult<Types.UpdateInterviewFeedbackMutation>;
|
|
2942
|
+
export type UpdateInterviewFeedbackMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewFeedbackMutation, Types.UpdateInterviewFeedbackMutationVariables>;
|
|
2943
|
+
export declare const UpdateInterviewRoundDocument: Apollo.DocumentNode;
|
|
2944
|
+
export type UpdateInterviewRoundMutationFn = Apollo.MutationFunction<Types.UpdateInterviewRoundMutation, Types.UpdateInterviewRoundMutationVariables>;
|
|
2945
|
+
/**
|
|
2946
|
+
* __useUpdateInterviewRoundMutation__
|
|
2947
|
+
*
|
|
2948
|
+
* To run a mutation, you first call `useUpdateInterviewRoundMutation` within a React component and pass it any options that fit your needs.
|
|
2949
|
+
* When your component renders, `useUpdateInterviewRoundMutation` returns a tuple that includes:
|
|
2950
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2951
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2952
|
+
*
|
|
2953
|
+
* @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;
|
|
2954
|
+
*
|
|
2955
|
+
* @example
|
|
2956
|
+
* const [updateInterviewRoundMutation, { data, loading, error }] = useUpdateInterviewRoundMutation({
|
|
2957
|
+
* variables: {
|
|
2958
|
+
* id: // value for 'id'
|
|
2959
|
+
* input: // value for 'input'
|
|
2960
|
+
* },
|
|
2961
|
+
* });
|
|
2962
|
+
*/
|
|
2963
|
+
export declare function useUpdateInterviewRoundMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewRoundMutation, Types.UpdateInterviewRoundMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewRoundMutation, any, Apollo.ApolloCache, undefined>;
|
|
2964
|
+
export type UpdateInterviewRoundMutationHookResult = ReturnType<typeof useUpdateInterviewRoundMutation>;
|
|
2965
|
+
export type UpdateInterviewRoundMutationResult = Apollo.MutationResult<Types.UpdateInterviewRoundMutation>;
|
|
2966
|
+
export type UpdateInterviewRoundMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewRoundMutation, Types.UpdateInterviewRoundMutationVariables>;
|
|
2967
|
+
export declare const UpdateInterviewRoundConfigDocument: Apollo.DocumentNode;
|
|
2968
|
+
export type UpdateInterviewRoundConfigMutationFn = Apollo.MutationFunction<Types.UpdateInterviewRoundConfigMutation, Types.UpdateInterviewRoundConfigMutationVariables>;
|
|
2969
|
+
/**
|
|
2970
|
+
* __useUpdateInterviewRoundConfigMutation__
|
|
2971
|
+
*
|
|
2972
|
+
* To run a mutation, you first call `useUpdateInterviewRoundConfigMutation` within a React component and pass it any options that fit your needs.
|
|
2973
|
+
* When your component renders, `useUpdateInterviewRoundConfigMutation` returns a tuple that includes:
|
|
2974
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2975
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2976
|
+
*
|
|
2977
|
+
* @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;
|
|
2978
|
+
*
|
|
2979
|
+
* @example
|
|
2980
|
+
* const [updateInterviewRoundConfigMutation, { data, loading, error }] = useUpdateInterviewRoundConfigMutation({
|
|
2981
|
+
* variables: {
|
|
2982
|
+
* id: // value for 'id'
|
|
2983
|
+
* input: // value for 'input'
|
|
2984
|
+
* },
|
|
2985
|
+
* });
|
|
2986
|
+
*/
|
|
2987
|
+
export declare function useUpdateInterviewRoundConfigMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewRoundConfigMutation, Types.UpdateInterviewRoundConfigMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewRoundConfigMutation, any, Apollo.ApolloCache, undefined>;
|
|
2988
|
+
export type UpdateInterviewRoundConfigMutationHookResult = ReturnType<typeof useUpdateInterviewRoundConfigMutation>;
|
|
2989
|
+
export type UpdateInterviewRoundConfigMutationResult = Apollo.MutationResult<Types.UpdateInterviewRoundConfigMutation>;
|
|
2990
|
+
export type UpdateInterviewRoundConfigMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewRoundConfigMutation, Types.UpdateInterviewRoundConfigMutationVariables>;
|
|
2991
|
+
export declare const UpdateInterviewerDocument: Apollo.DocumentNode;
|
|
2992
|
+
export type UpdateInterviewerMutationFn = Apollo.MutationFunction<Types.UpdateInterviewerMutation, Types.UpdateInterviewerMutationVariables>;
|
|
2993
|
+
/**
|
|
2994
|
+
* __useUpdateInterviewerMutation__
|
|
2995
|
+
*
|
|
2996
|
+
* To run a mutation, you first call `useUpdateInterviewerMutation` within a React component and pass it any options that fit your needs.
|
|
2997
|
+
* When your component renders, `useUpdateInterviewerMutation` returns a tuple that includes:
|
|
2998
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2999
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3000
|
+
*
|
|
3001
|
+
* @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;
|
|
3002
|
+
*
|
|
3003
|
+
* @example
|
|
3004
|
+
* const [updateInterviewerMutation, { data, loading, error }] = useUpdateInterviewerMutation({
|
|
3005
|
+
* variables: {
|
|
3006
|
+
* id: // value for 'id'
|
|
3007
|
+
* input: // value for 'input'
|
|
3008
|
+
* },
|
|
3009
|
+
* });
|
|
3010
|
+
*/
|
|
3011
|
+
export declare function useUpdateInterviewerMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateInterviewerMutation, Types.UpdateInterviewerMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateInterviewerMutation, any, Apollo.ApolloCache, undefined>;
|
|
3012
|
+
export type UpdateInterviewerMutationHookResult = ReturnType<typeof useUpdateInterviewerMutation>;
|
|
3013
|
+
export type UpdateInterviewerMutationResult = Apollo.MutationResult<Types.UpdateInterviewerMutation>;
|
|
3014
|
+
export type UpdateInterviewerMutationOptions = Apollo.BaseMutationOptions<Types.UpdateInterviewerMutation, Types.UpdateInterviewerMutationVariables>;
|
|
1789
3015
|
export declare const UpdateJobApplicationStatusDocument: Apollo.DocumentNode;
|
|
1790
3016
|
export type UpdateJobApplicationStatusMutationFn = Apollo.MutationFunction<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>;
|
|
1791
3017
|
/**
|
|
@@ -1810,6 +3036,54 @@ export declare function useUpdateJobApplicationStatusMutation(baseOptions?: Apol
|
|
|
1810
3036
|
export type UpdateJobApplicationStatusMutationHookResult = ReturnType<typeof useUpdateJobApplicationStatusMutation>;
|
|
1811
3037
|
export type UpdateJobApplicationStatusMutationResult = Apollo.MutationResult<Types.UpdateJobApplicationStatusMutation>;
|
|
1812
3038
|
export type UpdateJobApplicationStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>;
|
|
3039
|
+
export declare const UpdateJobAssignmentDocument: Apollo.DocumentNode;
|
|
3040
|
+
export type UpdateJobAssignmentMutationFn = Apollo.MutationFunction<Types.UpdateJobAssignmentMutation, Types.UpdateJobAssignmentMutationVariables>;
|
|
3041
|
+
/**
|
|
3042
|
+
* __useUpdateJobAssignmentMutation__
|
|
3043
|
+
*
|
|
3044
|
+
* To run a mutation, you first call `useUpdateJobAssignmentMutation` within a React component and pass it any options that fit your needs.
|
|
3045
|
+
* When your component renders, `useUpdateJobAssignmentMutation` returns a tuple that includes:
|
|
3046
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3047
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3048
|
+
*
|
|
3049
|
+
* @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;
|
|
3050
|
+
*
|
|
3051
|
+
* @example
|
|
3052
|
+
* const [updateJobAssignmentMutation, { data, loading, error }] = useUpdateJobAssignmentMutation({
|
|
3053
|
+
* variables: {
|
|
3054
|
+
* id: // value for 'id'
|
|
3055
|
+
* input: // value for 'input'
|
|
3056
|
+
* },
|
|
3057
|
+
* });
|
|
3058
|
+
*/
|
|
3059
|
+
export declare function useUpdateJobAssignmentMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateJobAssignmentMutation, Types.UpdateJobAssignmentMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateJobAssignmentMutation, any, Apollo.ApolloCache, undefined>;
|
|
3060
|
+
export type UpdateJobAssignmentMutationHookResult = ReturnType<typeof useUpdateJobAssignmentMutation>;
|
|
3061
|
+
export type UpdateJobAssignmentMutationResult = Apollo.MutationResult<Types.UpdateJobAssignmentMutation>;
|
|
3062
|
+
export type UpdateJobAssignmentMutationOptions = Apollo.BaseMutationOptions<Types.UpdateJobAssignmentMutation, Types.UpdateJobAssignmentMutationVariables>;
|
|
3063
|
+
export declare const UpdateJobPostingDocument: Apollo.DocumentNode;
|
|
3064
|
+
export type UpdateJobPostingMutationFn = Apollo.MutationFunction<Types.UpdateJobPostingMutation, Types.UpdateJobPostingMutationVariables>;
|
|
3065
|
+
/**
|
|
3066
|
+
* __useUpdateJobPostingMutation__
|
|
3067
|
+
*
|
|
3068
|
+
* To run a mutation, you first call `useUpdateJobPostingMutation` within a React component and pass it any options that fit your needs.
|
|
3069
|
+
* When your component renders, `useUpdateJobPostingMutation` returns a tuple that includes:
|
|
3070
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3071
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3072
|
+
*
|
|
3073
|
+
* @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;
|
|
3074
|
+
*
|
|
3075
|
+
* @example
|
|
3076
|
+
* const [updateJobPostingMutation, { data, loading, error }] = useUpdateJobPostingMutation({
|
|
3077
|
+
* variables: {
|
|
3078
|
+
* id: // value for 'id'
|
|
3079
|
+
* input: // value for 'input'
|
|
3080
|
+
* },
|
|
3081
|
+
* });
|
|
3082
|
+
*/
|
|
3083
|
+
export declare function useUpdateJobPostingMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateJobPostingMutation, Types.UpdateJobPostingMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateJobPostingMutation, any, Apollo.ApolloCache, undefined>;
|
|
3084
|
+
export type UpdateJobPostingMutationHookResult = ReturnType<typeof useUpdateJobPostingMutation>;
|
|
3085
|
+
export type UpdateJobPostingMutationResult = Apollo.MutationResult<Types.UpdateJobPostingMutation>;
|
|
3086
|
+
export type UpdateJobPostingMutationOptions = Apollo.BaseMutationOptions<Types.UpdateJobPostingMutation, Types.UpdateJobPostingMutationVariables>;
|
|
1813
3087
|
export declare const UpdateSlaPolicyDocument: Apollo.DocumentNode;
|
|
1814
3088
|
export type UpdateSlaPolicyMutationFn = Apollo.MutationFunction<Types.UpdateSlaPolicyMutation, Types.UpdateSlaPolicyMutationVariables>;
|
|
1815
3089
|
/**
|
|
@@ -2102,6 +3376,63 @@ export type GetContactInquiryQueryHookResult = ReturnType<typeof useGetContactIn
|
|
|
2102
3376
|
export type GetContactInquiryLazyQueryHookResult = ReturnType<typeof useGetContactInquiryLazyQuery>;
|
|
2103
3377
|
export type GetContactInquirySuspenseQueryHookResult = ReturnType<typeof useGetContactInquirySuspenseQuery>;
|
|
2104
3378
|
export type GetContactInquiryQueryResult = Apollo.QueryResult<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>;
|
|
3379
|
+
export declare const GetInterviewerDocument: Apollo.DocumentNode;
|
|
3380
|
+
/**
|
|
3381
|
+
* __useGetInterviewerQuery__
|
|
3382
|
+
*
|
|
3383
|
+
* To run a query within a React component, call `useGetInterviewerQuery` and pass it any options that fit your needs.
|
|
3384
|
+
* When your component renders, `useGetInterviewerQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3385
|
+
* you can use to render your UI.
|
|
3386
|
+
*
|
|
3387
|
+
* @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;
|
|
3388
|
+
*
|
|
3389
|
+
* @example
|
|
3390
|
+
* const { data, loading, error } = useGetInterviewerQuery({
|
|
3391
|
+
* variables: {
|
|
3392
|
+
* id: // value for 'id'
|
|
3393
|
+
* },
|
|
3394
|
+
* });
|
|
3395
|
+
*/
|
|
3396
|
+
export declare function useGetInterviewerQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables> & ({
|
|
3397
|
+
variables: Types.GetInterviewerQueryVariables;
|
|
3398
|
+
skip?: boolean;
|
|
3399
|
+
} | {
|
|
3400
|
+
skip: boolean;
|
|
3401
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables, "empty" | "complete" | "streaming", Types.GetInterviewerQueryVariables>;
|
|
3402
|
+
export declare function useGetInterviewerLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables, "empty" | "complete" | "streaming">;
|
|
3403
|
+
export declare function useGetInterviewerSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>;
|
|
3404
|
+
export declare function useGetInterviewerSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewerQuery | undefined, Types.GetInterviewerQueryVariables>;
|
|
3405
|
+
export type GetInterviewerQueryHookResult = ReturnType<typeof useGetInterviewerQuery>;
|
|
3406
|
+
export type GetInterviewerLazyQueryHookResult = ReturnType<typeof useGetInterviewerLazyQuery>;
|
|
3407
|
+
export type GetInterviewerSuspenseQueryHookResult = ReturnType<typeof useGetInterviewerSuspenseQuery>;
|
|
3408
|
+
export type GetInterviewerQueryResult = Apollo.QueryResult<Types.GetInterviewerQuery, Types.GetInterviewerQueryVariables>;
|
|
3409
|
+
export declare const GetInterviewersDocument: Apollo.DocumentNode;
|
|
3410
|
+
/**
|
|
3411
|
+
* __useGetInterviewersQuery__
|
|
3412
|
+
*
|
|
3413
|
+
* To run a query within a React component, call `useGetInterviewersQuery` and pass it any options that fit your needs.
|
|
3414
|
+
* When your component renders, `useGetInterviewersQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3415
|
+
* you can use to render your UI.
|
|
3416
|
+
*
|
|
3417
|
+
* @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;
|
|
3418
|
+
*
|
|
3419
|
+
* @example
|
|
3420
|
+
* const { data, loading, error } = useGetInterviewersQuery({
|
|
3421
|
+
* variables: {
|
|
3422
|
+
* filter: // value for 'filter'
|
|
3423
|
+
* limit: // value for 'limit'
|
|
3424
|
+
* offset: // value for 'offset'
|
|
3425
|
+
* },
|
|
3426
|
+
* });
|
|
3427
|
+
*/
|
|
3428
|
+
export declare function useGetInterviewersQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables, "empty" | "complete" | "streaming", Types.GetInterviewersQueryVariables>;
|
|
3429
|
+
export declare function useGetInterviewersLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables, "empty" | "complete" | "streaming">;
|
|
3430
|
+
export declare function useGetInterviewersSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>;
|
|
3431
|
+
export declare function useGetInterviewersSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetInterviewersQuery | undefined, Types.GetInterviewersQueryVariables>;
|
|
3432
|
+
export type GetInterviewersQueryHookResult = ReturnType<typeof useGetInterviewersQuery>;
|
|
3433
|
+
export type GetInterviewersLazyQueryHookResult = ReturnType<typeof useGetInterviewersLazyQuery>;
|
|
3434
|
+
export type GetInterviewersSuspenseQueryHookResult = ReturnType<typeof useGetInterviewersSuspenseQuery>;
|
|
3435
|
+
export type GetInterviewersQueryResult = Apollo.QueryResult<Types.GetInterviewersQuery, Types.GetInterviewersQueryVariables>;
|
|
2105
3436
|
export declare const GetJobApplicationDocument: Apollo.DocumentNode;
|
|
2106
3437
|
/**
|
|
2107
3438
|
* __useGetJobApplicationQuery__
|
|
@@ -2132,6 +3463,36 @@ export type GetJobApplicationQueryHookResult = ReturnType<typeof useGetJobApplic
|
|
|
2132
3463
|
export type GetJobApplicationLazyQueryHookResult = ReturnType<typeof useGetJobApplicationLazyQuery>;
|
|
2133
3464
|
export type GetJobApplicationSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationSuspenseQuery>;
|
|
2134
3465
|
export type GetJobApplicationQueryResult = Apollo.QueryResult<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>;
|
|
3466
|
+
export declare const GetJobApplicationInterviewRoundsDocument: Apollo.DocumentNode;
|
|
3467
|
+
/**
|
|
3468
|
+
* __useGetJobApplicationInterviewRoundsQuery__
|
|
3469
|
+
*
|
|
3470
|
+
* To run a query within a React component, call `useGetJobApplicationInterviewRoundsQuery` and pass it any options that fit your needs.
|
|
3471
|
+
* When your component renders, `useGetJobApplicationInterviewRoundsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3472
|
+
* you can use to render your UI.
|
|
3473
|
+
*
|
|
3474
|
+
* @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;
|
|
3475
|
+
*
|
|
3476
|
+
* @example
|
|
3477
|
+
* const { data, loading, error } = useGetJobApplicationInterviewRoundsQuery({
|
|
3478
|
+
* variables: {
|
|
3479
|
+
* applicationId: // value for 'applicationId'
|
|
3480
|
+
* },
|
|
3481
|
+
* });
|
|
3482
|
+
*/
|
|
3483
|
+
export declare function useGetJobApplicationInterviewRoundsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables> & ({
|
|
3484
|
+
variables: Types.GetJobApplicationInterviewRoundsQueryVariables;
|
|
3485
|
+
skip?: boolean;
|
|
3486
|
+
} | {
|
|
3487
|
+
skip: boolean;
|
|
3488
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationInterviewRoundsQueryVariables>;
|
|
3489
|
+
export declare function useGetJobApplicationInterviewRoundsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables, "empty" | "complete" | "streaming">;
|
|
3490
|
+
export declare function useGetJobApplicationInterviewRoundsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>;
|
|
3491
|
+
export declare function useGetJobApplicationInterviewRoundsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationInterviewRoundsQuery | undefined, Types.GetJobApplicationInterviewRoundsQueryVariables>;
|
|
3492
|
+
export type GetJobApplicationInterviewRoundsQueryHookResult = ReturnType<typeof useGetJobApplicationInterviewRoundsQuery>;
|
|
3493
|
+
export type GetJobApplicationInterviewRoundsLazyQueryHookResult = ReturnType<typeof useGetJobApplicationInterviewRoundsLazyQuery>;
|
|
3494
|
+
export type GetJobApplicationInterviewRoundsSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationInterviewRoundsSuspenseQuery>;
|
|
3495
|
+
export type GetJobApplicationInterviewRoundsQueryResult = Apollo.QueryResult<Types.GetJobApplicationInterviewRoundsQuery, Types.GetJobApplicationInterviewRoundsQueryVariables>;
|
|
2135
3496
|
export declare const GetJobApplicationResumeUrlDocument: Apollo.DocumentNode;
|
|
2136
3497
|
/**
|
|
2137
3498
|
* __useGetJobApplicationResumeUrlQuery__
|
|
@@ -2189,6 +3550,90 @@ export type GetJobApplicationsQueryHookResult = ReturnType<typeof useGetJobAppli
|
|
|
2189
3550
|
export type GetJobApplicationsLazyQueryHookResult = ReturnType<typeof useGetJobApplicationsLazyQuery>;
|
|
2190
3551
|
export type GetJobApplicationsSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationsSuspenseQuery>;
|
|
2191
3552
|
export type GetJobApplicationsQueryResult = Apollo.QueryResult<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>;
|
|
3553
|
+
export declare const GetJobAssignmentsDocument: Apollo.DocumentNode;
|
|
3554
|
+
/**
|
|
3555
|
+
* __useGetJobAssignmentsQuery__
|
|
3556
|
+
*
|
|
3557
|
+
* To run a query within a React component, call `useGetJobAssignmentsQuery` and pass it any options that fit your needs.
|
|
3558
|
+
* When your component renders, `useGetJobAssignmentsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3559
|
+
* you can use to render your UI.
|
|
3560
|
+
*
|
|
3561
|
+
* @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;
|
|
3562
|
+
*
|
|
3563
|
+
* @example
|
|
3564
|
+
* const { data, loading, error } = useGetJobAssignmentsQuery({
|
|
3565
|
+
* variables: {
|
|
3566
|
+
* filter: // value for 'filter'
|
|
3567
|
+
* limit: // value for 'limit'
|
|
3568
|
+
* offset: // value for 'offset'
|
|
3569
|
+
* },
|
|
3570
|
+
* });
|
|
3571
|
+
*/
|
|
3572
|
+
export declare function useGetJobAssignmentsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobAssignmentsQueryVariables>;
|
|
3573
|
+
export declare function useGetJobAssignmentsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables, "empty" | "complete" | "streaming">;
|
|
3574
|
+
export declare function useGetJobAssignmentsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>;
|
|
3575
|
+
export declare function useGetJobAssignmentsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobAssignmentsQuery | undefined, Types.GetJobAssignmentsQueryVariables>;
|
|
3576
|
+
export type GetJobAssignmentsQueryHookResult = ReturnType<typeof useGetJobAssignmentsQuery>;
|
|
3577
|
+
export type GetJobAssignmentsLazyQueryHookResult = ReturnType<typeof useGetJobAssignmentsLazyQuery>;
|
|
3578
|
+
export type GetJobAssignmentsSuspenseQueryHookResult = ReturnType<typeof useGetJobAssignmentsSuspenseQuery>;
|
|
3579
|
+
export type GetJobAssignmentsQueryResult = Apollo.QueryResult<Types.GetJobAssignmentsQuery, Types.GetJobAssignmentsQueryVariables>;
|
|
3580
|
+
export declare const GetJobPostingDocument: Apollo.DocumentNode;
|
|
3581
|
+
/**
|
|
3582
|
+
* __useGetJobPostingQuery__
|
|
3583
|
+
*
|
|
3584
|
+
* To run a query within a React component, call `useGetJobPostingQuery` and pass it any options that fit your needs.
|
|
3585
|
+
* When your component renders, `useGetJobPostingQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3586
|
+
* you can use to render your UI.
|
|
3587
|
+
*
|
|
3588
|
+
* @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;
|
|
3589
|
+
*
|
|
3590
|
+
* @example
|
|
3591
|
+
* const { data, loading, error } = useGetJobPostingQuery({
|
|
3592
|
+
* variables: {
|
|
3593
|
+
* id: // value for 'id'
|
|
3594
|
+
* },
|
|
3595
|
+
* });
|
|
3596
|
+
*/
|
|
3597
|
+
export declare function useGetJobPostingQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables> & ({
|
|
3598
|
+
variables: Types.GetJobPostingQueryVariables;
|
|
3599
|
+
skip?: boolean;
|
|
3600
|
+
} | {
|
|
3601
|
+
skip: boolean;
|
|
3602
|
+
})): ApolloReactHooks.useQuery.Result<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables, "empty" | "complete" | "streaming", Types.GetJobPostingQueryVariables>;
|
|
3603
|
+
export declare function useGetJobPostingLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables, "empty" | "complete" | "streaming">;
|
|
3604
|
+
export declare function useGetJobPostingSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>;
|
|
3605
|
+
export declare function useGetJobPostingSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingQuery | undefined, Types.GetJobPostingQueryVariables>;
|
|
3606
|
+
export type GetJobPostingQueryHookResult = ReturnType<typeof useGetJobPostingQuery>;
|
|
3607
|
+
export type GetJobPostingLazyQueryHookResult = ReturnType<typeof useGetJobPostingLazyQuery>;
|
|
3608
|
+
export type GetJobPostingSuspenseQueryHookResult = ReturnType<typeof useGetJobPostingSuspenseQuery>;
|
|
3609
|
+
export type GetJobPostingQueryResult = Apollo.QueryResult<Types.GetJobPostingQuery, Types.GetJobPostingQueryVariables>;
|
|
3610
|
+
export declare const GetJobPostingsDocument: Apollo.DocumentNode;
|
|
3611
|
+
/**
|
|
3612
|
+
* __useGetJobPostingsQuery__
|
|
3613
|
+
*
|
|
3614
|
+
* To run a query within a React component, call `useGetJobPostingsQuery` and pass it any options that fit your needs.
|
|
3615
|
+
* When your component renders, `useGetJobPostingsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3616
|
+
* you can use to render your UI.
|
|
3617
|
+
*
|
|
3618
|
+
* @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;
|
|
3619
|
+
*
|
|
3620
|
+
* @example
|
|
3621
|
+
* const { data, loading, error } = useGetJobPostingsQuery({
|
|
3622
|
+
* variables: {
|
|
3623
|
+
* filter: // value for 'filter'
|
|
3624
|
+
* limit: // value for 'limit'
|
|
3625
|
+
* offset: // value for 'offset'
|
|
3626
|
+
* },
|
|
3627
|
+
* });
|
|
3628
|
+
*/
|
|
3629
|
+
export declare function useGetJobPostingsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobPostingsQueryVariables>;
|
|
3630
|
+
export declare function useGetJobPostingsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables, "empty" | "complete" | "streaming">;
|
|
3631
|
+
export declare function useGetJobPostingsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>;
|
|
3632
|
+
export declare function useGetJobPostingsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobPostingsQuery | undefined, Types.GetJobPostingsQueryVariables>;
|
|
3633
|
+
export type GetJobPostingsQueryHookResult = ReturnType<typeof useGetJobPostingsQuery>;
|
|
3634
|
+
export type GetJobPostingsLazyQueryHookResult = ReturnType<typeof useGetJobPostingsLazyQuery>;
|
|
3635
|
+
export type GetJobPostingsSuspenseQueryHookResult = ReturnType<typeof useGetJobPostingsSuspenseQuery>;
|
|
3636
|
+
export type GetJobPostingsQueryResult = Apollo.QueryResult<Types.GetJobPostingsQuery, Types.GetJobPostingsQueryVariables>;
|
|
2192
3637
|
export declare const GetMyTicketsDocument: Apollo.DocumentNode;
|
|
2193
3638
|
/**
|
|
2194
3639
|
* __useGetMyTicketsQuery__
|