@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.
@@ -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 `useCreateSupportTicketMutation` within a React component and pass it any options that fit your needs.
1536
- * When your component renders, `useCreateSupportTicketMutation` returns a tuple that includes:
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 [createSupportTicketMutation, { data, loading, error }] = useCreateSupportTicketMutation({
2557
+ * const [deleteJobAssignmentMutation, { data, loading, error }] = useDeleteJobAssignmentMutation({
1544
2558
  * variables: {
1545
- * input: // value for 'input'
2559
+ * id: // value for 'id'
1546
2560
  * },
1547
2561
  * });
1548
2562
  */
1549
- export declare function useCreateSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
1550
- export type CreateSupportTicketMutationHookResult = ReturnType<typeof useCreateSupportTicketMutation>;
1551
- export type CreateSupportTicketMutationResult = Apollo.MutationResult<Types.CreateSupportTicketMutation>;
1552
- export type CreateSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>;
1553
- export declare const DeleteCannedResponseDocument: Apollo.DocumentNode;
1554
- export type DeleteCannedResponseMutationFn = Apollo.MutationFunction<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>;
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
- * __useDeleteCannedResponseMutation__
2570
+ * __useDeleteJobPostingMutation__
1557
2571
  *
1558
- * To run a mutation, you first call `useDeleteCannedResponseMutation` within a React component and pass it any options that fit your needs.
1559
- * When your component renders, `useDeleteCannedResponseMutation` returns a tuple that includes:
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 [deleteCannedResponseMutation, { data, loading, error }] = useDeleteCannedResponseMutation({
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 useDeleteCannedResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteCannedResponseMutation, any, Apollo.ApolloCache, undefined>;
1573
- export type DeleteCannedResponseMutationHookResult = ReturnType<typeof useDeleteCannedResponseMutation>;
1574
- export type DeleteCannedResponseMutationResult = Apollo.MutationResult<Types.DeleteCannedResponseMutation>;
1575
- export type DeleteCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.DeleteCannedResponseMutation, Types.DeleteCannedResponseMutationVariables>;
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__