@burdenoff/microfe-support 2026.625.2 → 2026.715.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.
Files changed (110) hide show
  1. package/dist/generated/global-operations.d.ts +2517 -0
  2. package/dist/generated/global-types.d.ts +22913 -0
  3. package/dist/generated/wspace-operations.d.ts +1 -0
  4. package/dist/generated/wspace-types.d.ts +57850 -0
  5. package/dist/index.d.ts +5 -0
  6. package/dist/support/SupportAdminRoot.d.ts +20 -0
  7. package/dist/support/SupportAdminRoutes.d.ts +13 -0
  8. package/dist/support/SupportUserRoot.d.ts +17 -0
  9. package/dist/support/SupportUserRoutes.d.ts +11 -0
  10. package/dist/support/components/NotificationToast.d.ts +17 -0
  11. package/dist/support/components/PageLayout.d.ts +71 -0
  12. package/dist/support/components/RouteHelpers.d.ts +9 -0
  13. package/dist/support/components/analytics/CategoryBreakdown.d.ts +9 -0
  14. package/dist/support/components/analytics/MetricCard.d.ts +10 -0
  15. package/dist/support/components/analytics/PriorityBreakdown.d.ts +9 -0
  16. package/dist/support/components/analytics/SLAReport.d.ts +23 -0
  17. package/dist/support/components/analytics/SatisfactionDistribution.d.ts +23 -0
  18. package/dist/support/components/analytics/TopAgents.d.ts +19 -0
  19. package/dist/support/components/analytics/TrendChart.d.ts +15 -0
  20. package/dist/support/components/kb/ArticleForm.d.ts +25 -0
  21. package/dist/support/components/settings/CannedResponsesSettings.d.ts +21 -0
  22. package/dist/support/components/settings/SLAPoliciesSettings.d.ts +18 -0
  23. package/dist/support/components/settings/TicketCategoriesSettings.d.ts +20 -0
  24. package/dist/support/components/tickets/AttachmentList.d.ts +7 -0
  25. package/dist/support/components/tickets/MarkdownContent.d.ts +7 -0
  26. package/dist/support/components/tickets/MessageComposer.d.ts +22 -0
  27. package/dist/support/components/tickets/MessageThread.d.ts +12 -0
  28. package/dist/support/components/tickets/TicketDetailHeader.d.ts +16 -0
  29. package/dist/support/components/tickets/TicketHeader.d.ts +9 -0
  30. package/dist/support/components/tickets/TicketSidebar.d.ts +7 -0
  31. package/dist/support/components/ui.d.ts +5 -0
  32. package/dist/support/components/ui.js +2 -2
  33. package/dist/support/constants.d.ts +20 -0
  34. package/dist/support/events/rybbit.d.ts +13 -0
  35. package/dist/support/hooks/index.d.ts +5 -0
  36. package/dist/support/hooks/useAnalyticsOperations.d.ts +51 -0
  37. package/dist/support/hooks/useAttachmentsFailedToast.d.ts +2 -0
  38. package/dist/support/hooks/useChatOperations.d.ts +27 -0
  39. package/dist/support/hooks/useKnowledgeBaseOperations.d.ts +55 -0
  40. package/dist/support/hooks/useNotification.d.ts +20 -0
  41. package/dist/support/hooks/useRegisterFooter.d.ts +6 -0
  42. package/dist/support/hooks/useSettingsOperations.d.ts +47 -0
  43. package/dist/support/hooks/useSupportAttachments.d.ts +10 -0
  44. package/dist/support/hooks/useTicketListOperations.d.ts +31 -0
  45. package/dist/support/hooks/useTicketOperations.d.ts +39 -0
  46. package/dist/support/index.d.ts +44 -0
  47. package/dist/support/pages/AnalyticsPage.d.ts +1 -0
  48. package/dist/support/pages/AnalyticsPage.js +144 -113
  49. package/dist/support/pages/AnalyticsPage.js.map +1 -1
  50. package/dist/support/pages/ArticleDetailAdminPage.d.ts +7 -0
  51. package/dist/support/pages/ArticleDetailAdminPage.js +150 -113
  52. package/dist/support/pages/ArticleDetailAdminPage.js.map +1 -1
  53. package/dist/support/pages/ArticleDetailUserPage.d.ts +7 -0
  54. package/dist/support/pages/ArticleDetailUserPage.js +90 -83
  55. package/dist/support/pages/ArticleDetailUserPage.js.map +1 -1
  56. package/dist/support/pages/ContactInquiriesPage.d.ts +1 -0
  57. package/dist/support/pages/ContactInquiriesPage.js +48 -44
  58. package/dist/support/pages/ContactInquiriesPage.js.map +1 -1
  59. package/dist/support/pages/ContactInquiryDetailPage.d.ts +1 -0
  60. package/dist/support/pages/ContactInquiryDetailPage.js +225 -205
  61. package/dist/support/pages/ContactInquiryDetailPage.js.map +1 -1
  62. package/dist/support/pages/CreateArticlePage.d.ts +1 -0
  63. package/dist/support/pages/CreateArticlePage.js +50 -46
  64. package/dist/support/pages/CreateArticlePage.js.map +1 -1
  65. package/dist/support/pages/CreateTicketPage.d.ts +1 -0
  66. package/dist/support/pages/CreateTicketPage.js +122 -116
  67. package/dist/support/pages/CreateTicketPage.js.map +1 -1
  68. package/dist/support/pages/EditArticlePage.d.ts +1 -0
  69. package/dist/support/pages/EditArticlePage.js +76 -80
  70. package/dist/support/pages/EditArticlePage.js.map +1 -1
  71. package/dist/support/pages/JobApplicationDetailPage.d.ts +1 -0
  72. package/dist/support/pages/JobApplicationDetailPage.js +292 -269
  73. package/dist/support/pages/JobApplicationDetailPage.js.map +1 -1
  74. package/dist/support/pages/JobApplicationsPage.d.ts +1 -0
  75. package/dist/support/pages/JobApplicationsPage.js +50 -46
  76. package/dist/support/pages/JobApplicationsPage.js.map +1 -1
  77. package/dist/support/pages/KnowledgeBaseAdminPage.d.ts +7 -0
  78. package/dist/support/pages/KnowledgeBaseAdminPage.js +84 -81
  79. package/dist/support/pages/KnowledgeBaseAdminPage.js.map +1 -1
  80. package/dist/support/pages/KnowledgeBaseUserPage.d.ts +8 -0
  81. package/dist/support/pages/KnowledgeBaseUserPage.js +76 -75
  82. package/dist/support/pages/KnowledgeBaseUserPage.js.map +1 -1
  83. package/dist/support/pages/SettingsPage.d.ts +1 -0
  84. package/dist/support/pages/SettingsPage.js +215 -182
  85. package/dist/support/pages/SettingsPage.js.map +1 -1
  86. package/dist/support/pages/TicketDetailAdminPage.d.ts +8 -0
  87. package/dist/support/pages/TicketDetailAdminPage.js +158 -128
  88. package/dist/support/pages/TicketDetailAdminPage.js.map +1 -1
  89. package/dist/support/pages/TicketDetailUserPage.d.ts +8 -0
  90. package/dist/support/pages/TicketDetailUserPage.js +174 -141
  91. package/dist/support/pages/TicketDetailUserPage.js.map +1 -1
  92. package/dist/support/pages/TicketListPage.d.ts +11 -0
  93. package/dist/support/pages/TicketListPage.js +171 -170
  94. package/dist/support/pages/TicketListPage.js.map +1 -1
  95. package/dist/support/providers/SupportProvider.d.ts +16 -0
  96. package/dist/support/store/supportStore.d.ts +66 -0
  97. package/dist/support/types/index.d.ts +160 -0
  98. package/dist/support/utils/attachments.d.ts +27 -0
  99. package/dist/support/utils/categoryColors.d.ts +10 -0
  100. package/dist/support/utils/cn.d.ts +6 -0
  101. package/dist/support/utils/context.d.ts +2 -0
  102. package/dist/support/utils/errors.d.ts +2 -0
  103. package/dist/support/utils/i18n.d.ts +4 -0
  104. package/dist/support/utils/index.d.ts +57 -0
  105. package/dist/support/utils/markdown.d.ts +2 -0
  106. package/dist/support/utils/supportFiles.d.ts +15 -0
  107. package/dist/support/utils/ticketFilters.d.ts +6 -0
  108. package/dist/support/utils/uiTokens.d.ts +7 -0
  109. package/dist/utils/nativeBridge.d.ts +2 -0
  110. package/package.json +4 -4
@@ -0,0 +1,2517 @@
1
+ import * as Types from './global-types';
2
+ import * as Apollo from '@apollo/client';
3
+ import * as ApolloReactHooks from '@apollo/client/react';
4
+ export type ArchiveKnowledgeBaseArticleMutationVariables = Types.Exact<{
5
+ id: Types.Scalars['ID']['input'];
6
+ }>;
7
+ export type ArchiveKnowledgeBaseArticleMutation = {
8
+ __typename?: 'Mutation';
9
+ archiveKnowledgeBaseArticle: {
10
+ __typename?: 'KnowledgeBaseArticle';
11
+ id: string;
12
+ status: Types.ArticleStatus;
13
+ archivedAt?: string | null;
14
+ };
15
+ };
16
+ export type CreateKnowledgeBaseArticleMutationVariables = Types.Exact<{
17
+ input: Types.CreateKnowledgeBaseArticleInput;
18
+ }>;
19
+ export type CreateKnowledgeBaseArticleMutation = {
20
+ __typename?: 'Mutation';
21
+ createKnowledgeBaseArticle: {
22
+ __typename?: 'KnowledgeBaseArticle';
23
+ id: string;
24
+ title: string;
25
+ slug: string;
26
+ content: string;
27
+ excerpt?: string | null;
28
+ status: Types.ArticleStatus;
29
+ categoryId?: string | null;
30
+ tags: Array<string>;
31
+ metaDescription?: string | null;
32
+ authorId: string;
33
+ createdAt: string;
34
+ };
35
+ };
36
+ export type CreateTicketCategoryMutationVariables = Types.Exact<{
37
+ input: Types.CreateTicketCategoryInput;
38
+ }>;
39
+ export type CreateTicketCategoryMutation = {
40
+ __typename?: 'Mutation';
41
+ createTicketCategory: {
42
+ __typename?: 'TicketCategory';
43
+ id: string;
44
+ name: string;
45
+ slug: string;
46
+ description?: string | null;
47
+ color?: string | null;
48
+ icon?: string | null;
49
+ isActive: boolean;
50
+ };
51
+ };
52
+ export type DeleteKnowledgeBaseArticleMutationVariables = Types.Exact<{
53
+ id: Types.Scalars['ID']['input'];
54
+ }>;
55
+ export type DeleteKnowledgeBaseArticleMutation = {
56
+ __typename?: 'Mutation';
57
+ deleteKnowledgeBaseArticle: boolean;
58
+ };
59
+ export type DeleteTicketCategoryMutationVariables = Types.Exact<{
60
+ id: Types.Scalars['ID']['input'];
61
+ }>;
62
+ export type DeleteTicketCategoryMutation = {
63
+ __typename?: 'Mutation';
64
+ deleteTicketCategory: boolean;
65
+ };
66
+ export type PublishKnowledgeBaseArticleMutationVariables = Types.Exact<{
67
+ id: Types.Scalars['ID']['input'];
68
+ }>;
69
+ export type PublishKnowledgeBaseArticleMutation = {
70
+ __typename?: 'Mutation';
71
+ publishKnowledgeBaseArticle: {
72
+ __typename?: 'KnowledgeBaseArticle';
73
+ id: string;
74
+ status: Types.ArticleStatus;
75
+ publishedAt?: string | null;
76
+ };
77
+ };
78
+ export type UnpublishKnowledgeBaseArticleMutationVariables = Types.Exact<{
79
+ id: Types.Scalars['ID']['input'];
80
+ }>;
81
+ export type UnpublishKnowledgeBaseArticleMutation = {
82
+ __typename?: 'Mutation';
83
+ unpublishKnowledgeBaseArticle: {
84
+ __typename?: 'KnowledgeBaseArticle';
85
+ id: string;
86
+ status: Types.ArticleStatus;
87
+ };
88
+ };
89
+ export type UpdateKnowledgeBaseArticleMutationVariables = Types.Exact<{
90
+ id: Types.Scalars['ID']['input'];
91
+ input: Types.UpdateKnowledgeBaseArticleInput;
92
+ }>;
93
+ export type UpdateKnowledgeBaseArticleMutation = {
94
+ __typename?: 'Mutation';
95
+ updateKnowledgeBaseArticle: {
96
+ __typename?: 'KnowledgeBaseArticle';
97
+ id: string;
98
+ title: string;
99
+ slug: string;
100
+ content: string;
101
+ excerpt?: string | null;
102
+ status: Types.ArticleStatus;
103
+ categoryId?: string | null;
104
+ tags: Array<string>;
105
+ metaDescription?: string | null;
106
+ updatedAt: string;
107
+ };
108
+ };
109
+ export type UpdateTicketCategoryMutationVariables = Types.Exact<{
110
+ id: Types.Scalars['ID']['input'];
111
+ input: Types.UpdateTicketCategoryInput;
112
+ }>;
113
+ export type UpdateTicketCategoryMutation = {
114
+ __typename?: 'Mutation';
115
+ updateTicketCategory: {
116
+ __typename?: 'TicketCategory';
117
+ id: string;
118
+ name: string;
119
+ slug: string;
120
+ description?: string | null;
121
+ color?: string | null;
122
+ icon?: string | null;
123
+ isActive: boolean;
124
+ };
125
+ };
126
+ export type CreateSupportMessageMutationVariables = Types.Exact<{
127
+ input: Types.CreateSupportMessageInput;
128
+ }>;
129
+ export type CreateSupportMessageMutation = {
130
+ __typename?: 'Mutation';
131
+ createSupportMessage: {
132
+ __typename?: 'SupportMessage';
133
+ id: string;
134
+ ticketId: string;
135
+ authorId: string;
136
+ message: string;
137
+ type: Types.MessageType;
138
+ attachments: Array<string>;
139
+ attachmentCount: number;
140
+ isInternal: boolean;
141
+ createdAt: string;
142
+ updatedAt: string;
143
+ };
144
+ };
145
+ export type AssignSupportTicketMutationVariables = Types.Exact<{
146
+ id: Types.Scalars['ID']['input'];
147
+ assignedTo: Types.Scalars['String']['input'];
148
+ }>;
149
+ export type AssignSupportTicketMutation = {
150
+ __typename?: 'Mutation';
151
+ assignSupportTicket: {
152
+ __typename?: 'SupportTicket';
153
+ id: string;
154
+ ticketNumber: string;
155
+ assignedTo?: string | null;
156
+ updatedAt: string;
157
+ };
158
+ };
159
+ export type UpdateSupportTicketStatusMutationVariables = Types.Exact<{
160
+ id: Types.Scalars['ID']['input'];
161
+ status: Types.SupportTicketStatus;
162
+ }>;
163
+ export type UpdateSupportTicketStatusMutation = {
164
+ __typename?: 'Mutation';
165
+ updateSupportTicketStatus: {
166
+ __typename?: 'SupportTicket';
167
+ id: string;
168
+ ticketNumber: string;
169
+ status: Types.SupportTicketStatus;
170
+ resolvedAt?: string | null;
171
+ closedAt?: string | null;
172
+ updatedAt: string;
173
+ };
174
+ };
175
+ export type CloseSupportTicketMutationVariables = Types.Exact<{
176
+ id: Types.Scalars['ID']['input'];
177
+ }>;
178
+ export type CloseSupportTicketMutation = {
179
+ __typename?: 'Mutation';
180
+ closeSupportTicket: {
181
+ __typename?: 'SupportTicket';
182
+ id: string;
183
+ ticketNumber: string;
184
+ status: Types.SupportTicketStatus;
185
+ resolvedAt?: string | null;
186
+ closedAt?: string | null;
187
+ updatedAt: string;
188
+ surveys: Array<{
189
+ __typename?: 'CustomerSatisfactionSurvey';
190
+ id: string;
191
+ rating: number;
192
+ comment?: string | null;
193
+ feedbackType?: Types.FeedbackCategory | null;
194
+ submittedAt?: string | null;
195
+ createdAt: string;
196
+ }>;
197
+ };
198
+ };
199
+ export type CreateCannedResponseMutationVariables = Types.Exact<{
200
+ input: Types.CreateCannedResponseInput;
201
+ }>;
202
+ export type CreateCannedResponseMutation = {
203
+ __typename?: 'Mutation';
204
+ createCannedResponse: {
205
+ __typename?: 'CannedResponse';
206
+ id: string;
207
+ tenantId?: string | null;
208
+ title: string;
209
+ content: string;
210
+ tags: Array<string>;
211
+ createdAt: string;
212
+ updatedAt: string;
213
+ };
214
+ };
215
+ export type CreateSlaPolicyMutationVariables = Types.Exact<{
216
+ input: Types.CreateSlaPolicyInput;
217
+ }>;
218
+ export type CreateSlaPolicyMutation = {
219
+ __typename?: 'Mutation';
220
+ createSLAPolicy: {
221
+ __typename?: 'SLAPolicy';
222
+ id: string;
223
+ tenantId?: string | null;
224
+ name: string;
225
+ description?: string | null;
226
+ priority: Types.SupportTicketPriority;
227
+ firstResponseMinutes: number;
228
+ resolutionMinutes: number;
229
+ businessHours?: Record<string, unknown> | null;
230
+ isActive: boolean;
231
+ isDefault: boolean;
232
+ createdAt: string;
233
+ updatedAt: string;
234
+ };
235
+ };
236
+ export type CreateSupportTicketMutationVariables = Types.Exact<{
237
+ input: Types.CreateSupportTicketInput;
238
+ }>;
239
+ export type CreateSupportTicketMutation = {
240
+ __typename?: 'Mutation';
241
+ createSupportTicket: {
242
+ __typename?: 'SupportTicket';
243
+ id: string;
244
+ ticketNumber: string;
245
+ subject: string;
246
+ description: string;
247
+ status: Types.SupportTicketStatus;
248
+ priority: Types.SupportTicketPriority;
249
+ category?: Types.SupportTicketCategory | null;
250
+ categoryId?: string | null;
251
+ source: Types.TicketSource;
252
+ tags: Array<string>;
253
+ dueAt?: string | null;
254
+ slaBreachStatus: Types.SlaBreachStatus;
255
+ createdAt: string;
256
+ updatedAt: string;
257
+ user: {
258
+ __typename?: 'User';
259
+ id: string;
260
+ };
261
+ ticketCategory?: {
262
+ __typename?: 'TicketCategory';
263
+ id: string;
264
+ name: string;
265
+ color?: string | null;
266
+ } | null;
267
+ };
268
+ };
269
+ export type DeleteCannedResponseMutationVariables = Types.Exact<{
270
+ id: Types.Scalars['ID']['input'];
271
+ }>;
272
+ export type DeleteCannedResponseMutation = {
273
+ __typename?: 'Mutation';
274
+ deleteCannedResponse: boolean;
275
+ };
276
+ export type DeleteSlaPolicyMutationVariables = Types.Exact<{
277
+ id: Types.Scalars['ID']['input'];
278
+ }>;
279
+ export type DeleteSlaPolicyMutation = {
280
+ __typename?: 'Mutation';
281
+ deleteSLAPolicy: boolean;
282
+ };
283
+ export type RateArticleMutationVariables = Types.Exact<{
284
+ id: Types.Scalars['ID']['input'];
285
+ helpful: Types.Scalars['Boolean']['input'];
286
+ }>;
287
+ export type RateArticleMutation = {
288
+ __typename?: 'Mutation';
289
+ rateArticle: {
290
+ __typename?: 'KnowledgeBaseArticle';
291
+ id: string;
292
+ helpfulCount: number;
293
+ notHelpfulCount: number;
294
+ };
295
+ };
296
+ export type RecordArticleViewMutationVariables = Types.Exact<{
297
+ id: Types.Scalars['ID']['input'];
298
+ }>;
299
+ export type RecordArticleViewMutation = {
300
+ __typename?: 'Mutation';
301
+ recordArticleView: {
302
+ __typename?: 'KnowledgeBaseArticle';
303
+ id: string;
304
+ viewCount: number;
305
+ };
306
+ };
307
+ export type ReplyToContactInquiryMutationVariables = Types.Exact<{
308
+ id: Types.Scalars['ID']['input'];
309
+ message: Types.Scalars['String']['input'];
310
+ }>;
311
+ export type ReplyToContactInquiryMutation = {
312
+ __typename?: 'Mutation';
313
+ replyToContactInquiry: {
314
+ __typename?: 'ContactInquiryReplyResult';
315
+ success: boolean;
316
+ message?: string | null;
317
+ };
318
+ };
319
+ export type ReplyToJobApplicationMutationVariables = Types.Exact<{
320
+ id: Types.Scalars['ID']['input'];
321
+ message: Types.Scalars['String']['input'];
322
+ }>;
323
+ export type ReplyToJobApplicationMutation = {
324
+ __typename?: 'Mutation';
325
+ replyToJobApplication: {
326
+ __typename?: 'JobApplicationReplyResult';
327
+ success: boolean;
328
+ message?: string | null;
329
+ };
330
+ };
331
+ export type ResolveSupportTicketMutationVariables = Types.Exact<{
332
+ id: Types.Scalars['ID']['input'];
333
+ resolution?: Types.InputMaybe<Types.Scalars['String']['input']>;
334
+ }>;
335
+ export type ResolveSupportTicketMutation = {
336
+ __typename?: 'Mutation';
337
+ resolveSupportTicket: {
338
+ __typename?: 'SupportTicket';
339
+ id: string;
340
+ ticketNumber: string;
341
+ status: Types.SupportTicketStatus;
342
+ resolvedAt?: string | null;
343
+ updatedAt: string;
344
+ };
345
+ };
346
+ export type SubmitSatisfactionSurveyMutationVariables = Types.Exact<{
347
+ input: Types.SubmitSatisfactionSurveyInput;
348
+ }>;
349
+ export type SubmitSatisfactionSurveyMutation = {
350
+ __typename?: 'Mutation';
351
+ submitSatisfactionSurvey: {
352
+ __typename?: 'CustomerSatisfactionSurvey';
353
+ id: string;
354
+ rating: number;
355
+ feedbackType?: Types.FeedbackCategory | null;
356
+ comment?: string | null;
357
+ submittedAt?: string | null;
358
+ };
359
+ };
360
+ export type UpdateCannedResponseMutationVariables = Types.Exact<{
361
+ id: Types.Scalars['ID']['input'];
362
+ input: Types.UpdateCannedResponseInput;
363
+ }>;
364
+ export type UpdateCannedResponseMutation = {
365
+ __typename?: 'Mutation';
366
+ updateCannedResponse: {
367
+ __typename?: 'CannedResponse';
368
+ id: string;
369
+ tenantId?: string | null;
370
+ title: string;
371
+ content: string;
372
+ tags: Array<string>;
373
+ createdAt: string;
374
+ updatedAt: string;
375
+ };
376
+ };
377
+ export type UpdateContactInquiryStatusMutationVariables = Types.Exact<{
378
+ id: Types.Scalars['ID']['input'];
379
+ input: Types.UpdateContactInquiryStatusInput;
380
+ }>;
381
+ export type UpdateContactInquiryStatusMutation = {
382
+ __typename?: 'Mutation';
383
+ updateContactInquiryStatus: {
384
+ __typename?: 'ContactInquiry';
385
+ id: string;
386
+ status: Types.ContactInquiryStatus;
387
+ convertedTicketId?: string | null;
388
+ updatedAt: string;
389
+ };
390
+ };
391
+ export type UpdateJobApplicationStatusMutationVariables = Types.Exact<{
392
+ id: Types.Scalars['ID']['input'];
393
+ input: Types.UpdateJobApplicationStatusInput;
394
+ }>;
395
+ export type UpdateJobApplicationStatusMutation = {
396
+ __typename?: 'Mutation';
397
+ updateJobApplicationStatus: {
398
+ __typename?: 'JobApplication';
399
+ id: string;
400
+ status: Types.JobApplicationStatus;
401
+ updatedAt: string;
402
+ };
403
+ };
404
+ export type UpdateSlaPolicyMutationVariables = Types.Exact<{
405
+ id: Types.Scalars['ID']['input'];
406
+ input: Types.UpdateSlaPolicyInput;
407
+ }>;
408
+ export type UpdateSlaPolicyMutation = {
409
+ __typename?: 'Mutation';
410
+ updateSLAPolicy: {
411
+ __typename?: 'SLAPolicy';
412
+ id: string;
413
+ tenantId?: string | null;
414
+ name: string;
415
+ description?: string | null;
416
+ priority: Types.SupportTicketPriority;
417
+ firstResponseMinutes: number;
418
+ resolutionMinutes: number;
419
+ businessHours?: Record<string, unknown> | null;
420
+ isActive: boolean;
421
+ isDefault: boolean;
422
+ createdAt: string;
423
+ updatedAt: string;
424
+ };
425
+ };
426
+ export type UpdateSupportTicketMutationVariables = Types.Exact<{
427
+ id: Types.Scalars['ID']['input'];
428
+ input: Types.UpdateSupportTicketInput;
429
+ }>;
430
+ export type UpdateSupportTicketMutation = {
431
+ __typename?: 'Mutation';
432
+ updateSupportTicket: {
433
+ __typename?: 'SupportTicket';
434
+ id: string;
435
+ ticketNumber: string;
436
+ subject: string;
437
+ description: string;
438
+ status: Types.SupportTicketStatus;
439
+ priority: Types.SupportTicketPriority;
440
+ category?: Types.SupportTicketCategory | null;
441
+ categoryId?: string | null;
442
+ assignedTo?: string | null;
443
+ tags: Array<string>;
444
+ customFields?: Record<string, unknown> | null;
445
+ updatedAt: string;
446
+ };
447
+ };
448
+ export type GetAgentLeaderboardQueryVariables = Types.Exact<{
449
+ period?: Types.InputMaybe<Types.TimePeriod>;
450
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
451
+ }>;
452
+ export type GetAgentLeaderboardQuery = {
453
+ __typename?: 'Query';
454
+ agentLeaderboard: {
455
+ __typename?: 'AgentLeaderboard';
456
+ period: Types.TimePeriod;
457
+ agents: Array<{
458
+ __typename?: 'AgentRanking';
459
+ rank: number;
460
+ agentId: string;
461
+ score: number;
462
+ ticketsResolved: number;
463
+ averageRating?: number | null;
464
+ slaComplianceRate: number;
465
+ agent: {
466
+ __typename?: 'AgentProfile';
467
+ id: string;
468
+ userId: string;
469
+ status: Types.AgentStatus;
470
+ };
471
+ }>;
472
+ };
473
+ };
474
+ export type GetSlaReportQueryVariables = Types.Exact<{
475
+ filter?: Types.InputMaybe<Types.SlaReportFilterInput>;
476
+ }>;
477
+ export type GetSlaReportQuery = {
478
+ __typename?: 'Query';
479
+ slaReport: {
480
+ __typename?: 'SLAReport';
481
+ period: Types.TimePeriod;
482
+ startDate: string;
483
+ endDate: string;
484
+ totalTickets: number;
485
+ ticketsWithSLA: number;
486
+ totalBreaches: number;
487
+ breachRate: number;
488
+ firstResponseCompliance: number;
489
+ resolutionCompliance: number;
490
+ averageFirstResponseMinutes?: number | null;
491
+ averageResolutionMinutes?: number | null;
492
+ byPriority: Array<{
493
+ __typename?: 'SLAPriorityBreakdown';
494
+ priority: Types.SupportTicketPriority;
495
+ totalTickets: number;
496
+ firstResponseCompliance: number;
497
+ resolutionCompliance: number;
498
+ averageFirstResponseMinutes?: number | null;
499
+ averageResolutionMinutes?: number | null;
500
+ }>;
501
+ };
502
+ };
503
+ export type GetSatisfactionMetricsQueryVariables = Types.Exact<{
504
+ filter?: Types.InputMaybe<Types.SatisfactionMetricsFilterInput>;
505
+ }>;
506
+ export type GetSatisfactionMetricsQuery = {
507
+ __typename?: 'Query';
508
+ satisfactionMetrics: {
509
+ __typename?: 'SatisfactionMetrics';
510
+ period: Types.TimePeriod;
511
+ startDate: string;
512
+ endDate: string;
513
+ averageRating?: number | null;
514
+ csatScore?: number | null;
515
+ npsScore?: number | null;
516
+ responseRate: number;
517
+ totalResponses: number;
518
+ totalSurveysSent: number;
519
+ ratingDistribution: Array<{
520
+ __typename?: 'RatingDistribution';
521
+ rating: number;
522
+ count: number;
523
+ percentage: number;
524
+ }>;
525
+ feedbackBreakdown: Array<{
526
+ __typename?: 'FeedbackBreakdown';
527
+ category: Types.FeedbackCategory;
528
+ count: number;
529
+ percentage: number;
530
+ }>;
531
+ trendData: Array<{
532
+ __typename?: 'SatisfactionTrend';
533
+ date: string;
534
+ averageRating?: number | null;
535
+ csatScore?: number | null;
536
+ responseCount: number;
537
+ }>;
538
+ };
539
+ };
540
+ export type GetAgentProfilesQueryVariables = Types.Exact<{
541
+ filter?: Types.InputMaybe<Types.AgentProfileFilterInput>;
542
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
543
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
544
+ }>;
545
+ export type GetAgentProfilesQuery = {
546
+ __typename?: 'Query';
547
+ agentProfiles: {
548
+ __typename?: 'AgentProfileConnection';
549
+ totalCount: number;
550
+ hasMore: boolean;
551
+ nodes: Array<{
552
+ __typename?: 'AgentProfile';
553
+ id: string;
554
+ userId: string;
555
+ displayAlias?: string | null;
556
+ status: Types.AgentStatus;
557
+ isAvailable: boolean;
558
+ user: {
559
+ __typename?: 'User';
560
+ id: string;
561
+ name?: string | null;
562
+ email: string;
563
+ };
564
+ }>;
565
+ };
566
+ };
567
+ export type GetArticleQueryVariables = Types.Exact<{
568
+ id: Types.Scalars['ID']['input'];
569
+ }>;
570
+ export type GetArticleQuery = {
571
+ __typename?: 'Query';
572
+ knowledgeBaseArticle?: {
573
+ __typename?: 'KnowledgeBaseArticle';
574
+ id: string;
575
+ slug: string;
576
+ title: string;
577
+ content: string;
578
+ excerpt?: string | null;
579
+ status: Types.ArticleStatus;
580
+ viewCount: number;
581
+ helpfulCount: number;
582
+ notHelpfulCount: number;
583
+ publishedAt?: string | null;
584
+ categoryId?: string | null;
585
+ authorId: string;
586
+ tags: Array<string>;
587
+ metaDescription?: string | null;
588
+ version: number;
589
+ createdAt: string;
590
+ updatedAt: string;
591
+ } | null;
592
+ };
593
+ export type GetArticlesQueryVariables = Types.Exact<{
594
+ filter?: Types.InputMaybe<Types.KnowledgeBaseArticleFilterInput>;
595
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
596
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
597
+ }>;
598
+ export type GetArticlesQuery = {
599
+ __typename?: 'Query';
600
+ knowledgeBaseArticles: {
601
+ __typename?: 'KnowledgeBaseArticleConnection';
602
+ totalCount: number;
603
+ hasMore: boolean;
604
+ nodes: Array<{
605
+ __typename?: 'KnowledgeBaseArticle';
606
+ id: string;
607
+ slug: string;
608
+ title: string;
609
+ excerpt?: string | null;
610
+ status: Types.ArticleStatus;
611
+ viewCount: number;
612
+ helpfulCount: number;
613
+ notHelpfulCount: number;
614
+ publishedAt?: string | null;
615
+ categoryId?: string | null;
616
+ authorId: string;
617
+ tags: Array<string>;
618
+ createdAt: string;
619
+ updatedAt: string;
620
+ category?: {
621
+ __typename?: 'TicketCategory';
622
+ id: string;
623
+ name: string;
624
+ color?: string | null;
625
+ } | null;
626
+ }>;
627
+ };
628
+ };
629
+ export type GetCannedResponsesQueryVariables = Types.Exact<{
630
+ filter?: Types.InputMaybe<Types.CannedResponseFilterInput>;
631
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
632
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
633
+ }>;
634
+ export type GetCannedResponsesQuery = {
635
+ __typename?: 'Query';
636
+ cannedResponses: {
637
+ __typename?: 'CannedResponseConnection';
638
+ totalCount: number;
639
+ nodes: Array<{
640
+ __typename?: 'CannedResponse';
641
+ id: string;
642
+ tenantId?: string | null;
643
+ title: string;
644
+ content: string;
645
+ shortcut?: string | null;
646
+ category?: string | null;
647
+ tags: Array<string>;
648
+ usageCount: number;
649
+ isActive: boolean;
650
+ createdAt: string;
651
+ updatedAt: string;
652
+ }>;
653
+ };
654
+ };
655
+ export type GetContactInquiriesQueryVariables = Types.Exact<{
656
+ filter?: Types.InputMaybe<Types.ContactInquiryFilterInput>;
657
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
658
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
659
+ }>;
660
+ export type GetContactInquiriesQuery = {
661
+ __typename?: 'Query';
662
+ contactInquiries: {
663
+ __typename?: 'ContactInquiryList';
664
+ total: number;
665
+ hasMore: boolean;
666
+ items: Array<{
667
+ __typename?: 'ContactInquiry';
668
+ id: string;
669
+ name: string;
670
+ email: string;
671
+ company?: string | null;
672
+ subject: string;
673
+ category?: string | null;
674
+ message: string;
675
+ status: Types.ContactInquiryStatus;
676
+ source: string;
677
+ productId?: string | null;
678
+ convertedTicketId?: string | null;
679
+ metadata?: Record<string, unknown> | null;
680
+ createdAt: string;
681
+ updatedAt: string;
682
+ }>;
683
+ };
684
+ };
685
+ export type GetContactInquiryQueryVariables = Types.Exact<{
686
+ id: Types.Scalars['ID']['input'];
687
+ }>;
688
+ export type GetContactInquiryQuery = {
689
+ __typename?: 'Query';
690
+ contactInquiry?: {
691
+ __typename?: 'ContactInquiry';
692
+ id: string;
693
+ name: string;
694
+ email: string;
695
+ company?: string | null;
696
+ subject: string;
697
+ category?: string | null;
698
+ message: string;
699
+ status: Types.ContactInquiryStatus;
700
+ source: string;
701
+ productId?: string | null;
702
+ convertedTicketId?: string | null;
703
+ metadata?: Record<string, unknown> | null;
704
+ createdAt: string;
705
+ updatedAt: string;
706
+ } | null;
707
+ };
708
+ export type GetJobApplicationQueryVariables = Types.Exact<{
709
+ id: Types.Scalars['ID']['input'];
710
+ }>;
711
+ export type GetJobApplicationQuery = {
712
+ __typename?: 'Query';
713
+ jobApplication?: {
714
+ __typename?: 'JobApplication';
715
+ id: string;
716
+ firstName: string;
717
+ lastName: string;
718
+ email: string;
719
+ phone?: string | null;
720
+ position: string;
721
+ department?: string | null;
722
+ linkedinUrl?: string | null;
723
+ portfolioUrl?: string | null;
724
+ coverLetter?: string | null;
725
+ resumeFileName?: string | null;
726
+ resumeFileSize?: number | null;
727
+ resumeMimeType?: string | null;
728
+ productId?: string | null;
729
+ source: string;
730
+ status: Types.JobApplicationStatus;
731
+ metadata?: Record<string, unknown> | null;
732
+ createdAt: string;
733
+ updatedAt: string;
734
+ } | null;
735
+ };
736
+ export type GetJobApplicationResumeUrlQueryVariables = Types.Exact<{
737
+ id: Types.Scalars['ID']['input'];
738
+ }>;
739
+ export type GetJobApplicationResumeUrlQuery = {
740
+ __typename?: 'Query';
741
+ jobApplicationResumeUrl: string;
742
+ };
743
+ export type GetJobApplicationsQueryVariables = Types.Exact<{
744
+ filter?: Types.InputMaybe<Types.JobApplicationFilterInput>;
745
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
746
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
747
+ }>;
748
+ export type GetJobApplicationsQuery = {
749
+ __typename?: 'Query';
750
+ jobApplications: {
751
+ __typename?: 'JobApplicationList';
752
+ total: number;
753
+ hasMore: boolean;
754
+ items: Array<{
755
+ __typename?: 'JobApplication';
756
+ id: string;
757
+ firstName: string;
758
+ lastName: string;
759
+ email: string;
760
+ position: string;
761
+ department?: string | null;
762
+ resumeFileName?: string | null;
763
+ productId?: string | null;
764
+ status: Types.JobApplicationStatus;
765
+ createdAt: string;
766
+ }>;
767
+ };
768
+ };
769
+ export type GetMyTicketsQueryVariables = Types.Exact<{
770
+ filter?: Types.InputMaybe<Types.SupportTicketFilterInput>;
771
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
772
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
773
+ }>;
774
+ export type GetMyTicketsQuery = {
775
+ __typename?: 'Query';
776
+ supportTickets: {
777
+ __typename?: 'SupportTicketConnection';
778
+ totalCount: number;
779
+ hasMore: boolean;
780
+ nodes: Array<{
781
+ __typename?: 'SupportTicket';
782
+ id: string;
783
+ ticketNumber: string;
784
+ subject: string;
785
+ status: Types.SupportTicketStatus;
786
+ priority: Types.SupportTicketPriority;
787
+ category?: Types.SupportTicketCategory | null;
788
+ categoryId?: string | null;
789
+ assignedTo?: string | null;
790
+ slaBreachStatus: Types.SlaBreachStatus;
791
+ createdAt: string;
792
+ updatedAt: string;
793
+ context?: {
794
+ __typename?: 'SupportContext';
795
+ productId?: string | null;
796
+ } | null;
797
+ ticketCategory?: {
798
+ __typename?: 'TicketCategory';
799
+ id: string;
800
+ name: string;
801
+ color?: string | null;
802
+ } | null;
803
+ }>;
804
+ };
805
+ };
806
+ export type GetPopularArticlesQueryVariables = Types.Exact<{
807
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
808
+ }>;
809
+ export type GetPopularArticlesQuery = {
810
+ __typename?: 'Query';
811
+ popularArticles: Array<{
812
+ __typename?: 'KnowledgeBaseArticle';
813
+ id: string;
814
+ slug: string;
815
+ title: string;
816
+ excerpt?: string | null;
817
+ viewCount: number;
818
+ helpfulCount: number;
819
+ categoryId?: string | null;
820
+ tags: Array<string>;
821
+ }>;
822
+ };
823
+ export type GetSlaPoliciesQueryVariables = Types.Exact<{
824
+ filter?: Types.InputMaybe<Types.SlaPolicyFilterInput>;
825
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
826
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
827
+ }>;
828
+ export type GetSlaPoliciesQuery = {
829
+ __typename?: 'Query';
830
+ slaPolicies: {
831
+ __typename?: 'SLAPolicyConnection';
832
+ totalCount: number;
833
+ nodes: Array<{
834
+ __typename?: 'SLAPolicy';
835
+ id: string;
836
+ tenantId?: string | null;
837
+ name: string;
838
+ description?: string | null;
839
+ priority: Types.SupportTicketPriority;
840
+ firstResponseMinutes: number;
841
+ resolutionMinutes: number;
842
+ businessHours?: Record<string, unknown> | null;
843
+ isActive: boolean;
844
+ isDefault: boolean;
845
+ createdAt: string;
846
+ updatedAt: string;
847
+ }>;
848
+ };
849
+ };
850
+ export type GetSupportAnalyticsQueryVariables = Types.Exact<{
851
+ filter?: Types.InputMaybe<Types.AnalyticsFilterInput>;
852
+ }>;
853
+ export type GetSupportAnalyticsQuery = {
854
+ __typename?: 'Query';
855
+ supportAnalytics: {
856
+ __typename?: 'SupportAnalytics';
857
+ stats: {
858
+ __typename?: 'SupportStats';
859
+ totalTickets: number;
860
+ openTickets: number;
861
+ resolvedTickets: number;
862
+ closedTickets: number;
863
+ newTickets: number;
864
+ inProgressTickets: number;
865
+ waitingOnCustomerTickets: number;
866
+ reopenedTickets: number;
867
+ averageFirstResponseTimeHours?: number | null;
868
+ averageResolutionTimeHours?: number | null;
869
+ slaComplianceRate?: number | null;
870
+ };
871
+ priorityBreakdown: Array<{
872
+ __typename?: 'PriorityBreakdown';
873
+ priority: Types.SupportTicketPriority;
874
+ count: number;
875
+ percentage: number;
876
+ }>;
877
+ categoryBreakdown: Array<{
878
+ __typename?: 'CategoryBreakdown';
879
+ category: Types.SupportTicketCategory;
880
+ count: number;
881
+ percentage: number;
882
+ }>;
883
+ sourceBreakdown: Array<{
884
+ __typename?: 'SourceBreakdown';
885
+ source: Types.TicketSource;
886
+ count: number;
887
+ percentage: number;
888
+ }>;
889
+ ticketTrends: Array<{
890
+ __typename?: 'TicketTrend';
891
+ date: string;
892
+ count: number;
893
+ groupBy: Types.TrendGroupBy;
894
+ }>;
895
+ };
896
+ };
897
+ export type GetTicketCategoriesQueryVariables = Types.Exact<{
898
+ filter?: Types.InputMaybe<Types.TicketCategoryFilterInput>;
899
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
900
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
901
+ }>;
902
+ export type GetTicketCategoriesQuery = {
903
+ __typename?: 'Query';
904
+ ticketCategories: {
905
+ __typename?: 'TicketCategoryConnection';
906
+ totalCount: number;
907
+ hasMore: boolean;
908
+ nodes: Array<{
909
+ __typename?: 'TicketCategory';
910
+ id: string;
911
+ name: string;
912
+ slug: string;
913
+ color?: string | null;
914
+ icon?: string | null;
915
+ description?: string | null;
916
+ isActive: boolean;
917
+ displayOrder: number;
918
+ articleCount: number;
919
+ createdAt: string;
920
+ updatedAt: string;
921
+ }>;
922
+ };
923
+ };
924
+ export type GetTicketDetailQueryVariables = Types.Exact<{
925
+ id: Types.Scalars['ID']['input'];
926
+ }>;
927
+ export type GetTicketDetailQuery = {
928
+ __typename?: 'Query';
929
+ supportTicket?: {
930
+ __typename?: 'SupportTicket';
931
+ id: string;
932
+ ticketNumber: string;
933
+ subject: string;
934
+ description: string;
935
+ status: Types.SupportTicketStatus;
936
+ priority: Types.SupportTicketPriority;
937
+ category?: Types.SupportTicketCategory | null;
938
+ categoryId?: string | null;
939
+ source: Types.TicketSource;
940
+ assignedTo?: string | null;
941
+ tags: Array<string>;
942
+ dueAt?: string | null;
943
+ firstResponseAt?: string | null;
944
+ firstResponseDue?: string | null;
945
+ resolutionDue?: string | null;
946
+ slaBreachStatus: Types.SlaBreachStatus;
947
+ escalationLevel: number;
948
+ resolvedAt?: string | null;
949
+ closedAt?: string | null;
950
+ reopenedAt?: string | null;
951
+ metadata?: Record<string, unknown> | null;
952
+ customFields?: Record<string, unknown> | null;
953
+ createdAt: string;
954
+ updatedAt: string;
955
+ context?: {
956
+ __typename?: 'SupportContext';
957
+ workspaceId?: string | null;
958
+ organizationId?: string | null;
959
+ productId?: string | null;
960
+ custom?: Record<string, unknown> | null;
961
+ } | null;
962
+ user: {
963
+ __typename?: 'User';
964
+ id: string;
965
+ name?: string | null;
966
+ firstName?: string | null;
967
+ lastName?: string | null;
968
+ email: string;
969
+ isSupportAgent: boolean;
970
+ };
971
+ ticketCategory?: {
972
+ __typename?: 'TicketCategory';
973
+ id: string;
974
+ name: string;
975
+ color?: string | null;
976
+ } | null;
977
+ slaPolicy?: {
978
+ __typename?: 'SLAPolicy';
979
+ id: string;
980
+ name: string;
981
+ firstResponseMinutes: number;
982
+ resolutionMinutes: number;
983
+ isActive: boolean;
984
+ } | null;
985
+ messages: Array<{
986
+ __typename?: 'SupportMessage';
987
+ id: string;
988
+ ticketId: string;
989
+ authorId: string;
990
+ message: string;
991
+ type: Types.MessageType;
992
+ attachments: Array<string>;
993
+ attachmentCount: number;
994
+ isInternal: boolean;
995
+ createdAt: string;
996
+ updatedAt: string;
997
+ author: {
998
+ __typename?: 'SupportAuthor';
999
+ id: string;
1000
+ displayName: string;
1001
+ avatar: string;
1002
+ kind: Types.SupportAuthorKind;
1003
+ isAnonymized: boolean;
1004
+ };
1005
+ context?: {
1006
+ __typename?: 'SupportContext';
1007
+ workspaceId?: string | null;
1008
+ organizationId?: string | null;
1009
+ productId?: string | null;
1010
+ custom?: Record<string, unknown> | null;
1011
+ } | null;
1012
+ }>;
1013
+ linkedTickets: Array<{
1014
+ __typename?: 'TicketLink';
1015
+ id: string;
1016
+ fromTicketId: string;
1017
+ toTicketId: string;
1018
+ linkType: Types.LinkType;
1019
+ createdBy: string;
1020
+ createdAt: string;
1021
+ }>;
1022
+ surveys: Array<{
1023
+ __typename?: 'CustomerSatisfactionSurvey';
1024
+ id: string;
1025
+ rating: number;
1026
+ comment?: string | null;
1027
+ feedbackType?: Types.FeedbackCategory | null;
1028
+ submittedAt?: string | null;
1029
+ createdAt: string;
1030
+ }>;
1031
+ } | null;
1032
+ };
1033
+ export type GetTicketTrendsQueryVariables = Types.Exact<{
1034
+ filter?: Types.InputMaybe<Types.AnalyticsFilterInput>;
1035
+ }>;
1036
+ export type GetTicketTrendsQuery = {
1037
+ __typename?: 'Query';
1038
+ ticketTrends: Array<{
1039
+ __typename?: 'TicketTrend';
1040
+ date: string;
1041
+ count: number;
1042
+ groupBy: Types.TrendGroupBy;
1043
+ }>;
1044
+ };
1045
+ export type GetTicketsQueryVariables = Types.Exact<{
1046
+ filter?: Types.InputMaybe<Types.SupportTicketFilterInput>;
1047
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
1048
+ offset?: Types.InputMaybe<Types.Scalars['Int']['input']>;
1049
+ }>;
1050
+ export type GetTicketsQuery = {
1051
+ __typename?: 'Query';
1052
+ supportTickets: {
1053
+ __typename?: 'SupportTicketConnection';
1054
+ totalCount: number;
1055
+ hasMore: boolean;
1056
+ nodes: Array<{
1057
+ __typename?: 'SupportTicket';
1058
+ id: string;
1059
+ ticketNumber: string;
1060
+ subject: string;
1061
+ status: Types.SupportTicketStatus;
1062
+ priority: Types.SupportTicketPriority;
1063
+ category?: Types.SupportTicketCategory | null;
1064
+ categoryId?: string | null;
1065
+ assignedTo?: string | null;
1066
+ slaBreachStatus: Types.SlaBreachStatus;
1067
+ createdAt: string;
1068
+ updatedAt: string;
1069
+ context?: {
1070
+ __typename?: 'SupportContext';
1071
+ productId?: string | null;
1072
+ } | null;
1073
+ ticketCategory?: {
1074
+ __typename?: 'TicketCategory';
1075
+ id: string;
1076
+ name: string;
1077
+ color?: string | null;
1078
+ } | null;
1079
+ }>;
1080
+ };
1081
+ };
1082
+ export type SearchKnowledgeBaseQueryVariables = Types.Exact<{
1083
+ query: Types.Scalars['String']['input'];
1084
+ categoryId?: Types.InputMaybe<Types.Scalars['String']['input']>;
1085
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
1086
+ }>;
1087
+ export type SearchKnowledgeBaseQuery = {
1088
+ __typename?: 'Query';
1089
+ searchKnowledgeBase: Array<{
1090
+ __typename?: 'KnowledgeBaseArticle';
1091
+ id: string;
1092
+ slug: string;
1093
+ title: string;
1094
+ excerpt?: string | null;
1095
+ viewCount: number;
1096
+ helpfulCount: number;
1097
+ notHelpfulCount: number;
1098
+ publishedAt?: string | null;
1099
+ categoryId?: string | null;
1100
+ tags: Array<string>;
1101
+ category?: {
1102
+ __typename?: 'TicketCategory';
1103
+ id: string;
1104
+ name: string;
1105
+ color?: string | null;
1106
+ } | null;
1107
+ }>;
1108
+ };
1109
+ export type SearchTicketsQueryVariables = Types.Exact<{
1110
+ query: Types.Scalars['String']['input'];
1111
+ limit?: Types.InputMaybe<Types.Scalars['Int']['input']>;
1112
+ }>;
1113
+ export type SearchTicketsQuery = {
1114
+ __typename?: 'Query';
1115
+ searchTickets: Array<{
1116
+ __typename?: 'SupportTicket';
1117
+ id: string;
1118
+ ticketNumber: string;
1119
+ subject: string;
1120
+ status: Types.SupportTicketStatus;
1121
+ priority: Types.SupportTicketPriority;
1122
+ category?: Types.SupportTicketCategory | null;
1123
+ categoryId?: string | null;
1124
+ assignedTo?: string | null;
1125
+ slaBreachStatus: Types.SlaBreachStatus;
1126
+ createdAt: string;
1127
+ updatedAt: string;
1128
+ context?: {
1129
+ __typename?: 'SupportContext';
1130
+ productId?: string | null;
1131
+ } | null;
1132
+ ticketCategory?: {
1133
+ __typename?: 'TicketCategory';
1134
+ id: string;
1135
+ name: string;
1136
+ color?: string | null;
1137
+ } | null;
1138
+ }>;
1139
+ };
1140
+ export type SubscribeTicketMessageAddedSubscriptionVariables = Types.Exact<{
1141
+ ticketId: Types.Scalars['ID']['input'];
1142
+ }>;
1143
+ export type SubscribeTicketMessageAddedSubscription = {
1144
+ __typename?: 'Subscription';
1145
+ ticketMessageAdded: {
1146
+ __typename?: 'SupportMessage';
1147
+ id: string;
1148
+ ticketId: string;
1149
+ authorId: string;
1150
+ message: string;
1151
+ type: Types.MessageType;
1152
+ attachments: Array<string>;
1153
+ attachmentCount: number;
1154
+ isInternal: boolean;
1155
+ createdAt: string;
1156
+ updatedAt: string;
1157
+ author: {
1158
+ __typename?: 'SupportAuthor';
1159
+ id: string;
1160
+ displayName: string;
1161
+ avatar: string;
1162
+ kind: Types.SupportAuthorKind;
1163
+ isAnonymized: boolean;
1164
+ };
1165
+ };
1166
+ };
1167
+ export type SubscribeTicketUpdatedSubscriptionVariables = Types.Exact<{
1168
+ ticketId: Types.Scalars['ID']['input'];
1169
+ }>;
1170
+ export type SubscribeTicketUpdatedSubscription = {
1171
+ __typename?: 'Subscription';
1172
+ ticketUpdated: {
1173
+ __typename?: 'SupportTicket';
1174
+ id: string;
1175
+ status: Types.SupportTicketStatus;
1176
+ priority: Types.SupportTicketPriority;
1177
+ assignedTo?: string | null;
1178
+ updatedAt: string;
1179
+ };
1180
+ };
1181
+ export declare const ArchiveKnowledgeBaseArticleDocument: Apollo.DocumentNode;
1182
+ export type ArchiveKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.ArchiveKnowledgeBaseArticleMutation, Types.ArchiveKnowledgeBaseArticleMutationVariables>;
1183
+ /**
1184
+ * __useArchiveKnowledgeBaseArticleMutation__
1185
+ *
1186
+ * To run a mutation, you first call `useArchiveKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
1187
+ * When your component renders, `useArchiveKnowledgeBaseArticleMutation` returns a tuple that includes:
1188
+ * - A mutate function that you can call at any time to execute the mutation
1189
+ * - An object with fields that represent the current status of the mutation's execution
1190
+ *
1191
+ * @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;
1192
+ *
1193
+ * @example
1194
+ * const [archiveKnowledgeBaseArticleMutation, { data, loading, error }] = useArchiveKnowledgeBaseArticleMutation({
1195
+ * variables: {
1196
+ * id: // value for 'id'
1197
+ * },
1198
+ * });
1199
+ */
1200
+ export declare function useArchiveKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ArchiveKnowledgeBaseArticleMutation, Types.ArchiveKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ArchiveKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
1201
+ export type ArchiveKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useArchiveKnowledgeBaseArticleMutation>;
1202
+ export type ArchiveKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.ArchiveKnowledgeBaseArticleMutation>;
1203
+ export type ArchiveKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.ArchiveKnowledgeBaseArticleMutation, Types.ArchiveKnowledgeBaseArticleMutationVariables>;
1204
+ export declare const CreateKnowledgeBaseArticleDocument: Apollo.DocumentNode;
1205
+ export type CreateKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.CreateKnowledgeBaseArticleMutation, Types.CreateKnowledgeBaseArticleMutationVariables>;
1206
+ /**
1207
+ * __useCreateKnowledgeBaseArticleMutation__
1208
+ *
1209
+ * To run a mutation, you first call `useCreateKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
1210
+ * When your component renders, `useCreateKnowledgeBaseArticleMutation` returns a tuple that includes:
1211
+ * - A mutate function that you can call at any time to execute the mutation
1212
+ * - An object with fields that represent the current status of the mutation's execution
1213
+ *
1214
+ * @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;
1215
+ *
1216
+ * @example
1217
+ * const [createKnowledgeBaseArticleMutation, { data, loading, error }] = useCreateKnowledgeBaseArticleMutation({
1218
+ * variables: {
1219
+ * input: // value for 'input'
1220
+ * },
1221
+ * });
1222
+ */
1223
+ export declare function useCreateKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateKnowledgeBaseArticleMutation, Types.CreateKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
1224
+ export type CreateKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useCreateKnowledgeBaseArticleMutation>;
1225
+ export type CreateKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.CreateKnowledgeBaseArticleMutation>;
1226
+ export type CreateKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.CreateKnowledgeBaseArticleMutation, Types.CreateKnowledgeBaseArticleMutationVariables>;
1227
+ export declare const CreateTicketCategoryDocument: Apollo.DocumentNode;
1228
+ export type CreateTicketCategoryMutationFn = Apollo.MutationFunction<Types.CreateTicketCategoryMutation, Types.CreateTicketCategoryMutationVariables>;
1229
+ /**
1230
+ * __useCreateTicketCategoryMutation__
1231
+ *
1232
+ * To run a mutation, you first call `useCreateTicketCategoryMutation` within a React component and pass it any options that fit your needs.
1233
+ * When your component renders, `useCreateTicketCategoryMutation` returns a tuple that includes:
1234
+ * - A mutate function that you can call at any time to execute the mutation
1235
+ * - An object with fields that represent the current status of the mutation's execution
1236
+ *
1237
+ * @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;
1238
+ *
1239
+ * @example
1240
+ * const [createTicketCategoryMutation, { data, loading, error }] = useCreateTicketCategoryMutation({
1241
+ * variables: {
1242
+ * input: // value for 'input'
1243
+ * },
1244
+ * });
1245
+ */
1246
+ export declare function useCreateTicketCategoryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateTicketCategoryMutation, Types.CreateTicketCategoryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateTicketCategoryMutation, any, Apollo.ApolloCache, undefined>;
1247
+ export type CreateTicketCategoryMutationHookResult = ReturnType<typeof useCreateTicketCategoryMutation>;
1248
+ export type CreateTicketCategoryMutationResult = Apollo.MutationResult<Types.CreateTicketCategoryMutation>;
1249
+ export type CreateTicketCategoryMutationOptions = Apollo.BaseMutationOptions<Types.CreateTicketCategoryMutation, Types.CreateTicketCategoryMutationVariables>;
1250
+ export declare const DeleteKnowledgeBaseArticleDocument: Apollo.DocumentNode;
1251
+ export type DeleteKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.DeleteKnowledgeBaseArticleMutation, Types.DeleteKnowledgeBaseArticleMutationVariables>;
1252
+ /**
1253
+ * __useDeleteKnowledgeBaseArticleMutation__
1254
+ *
1255
+ * To run a mutation, you first call `useDeleteKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
1256
+ * When your component renders, `useDeleteKnowledgeBaseArticleMutation` returns a tuple that includes:
1257
+ * - A mutate function that you can call at any time to execute the mutation
1258
+ * - An object with fields that represent the current status of the mutation's execution
1259
+ *
1260
+ * @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;
1261
+ *
1262
+ * @example
1263
+ * const [deleteKnowledgeBaseArticleMutation, { data, loading, error }] = useDeleteKnowledgeBaseArticleMutation({
1264
+ * variables: {
1265
+ * id: // value for 'id'
1266
+ * },
1267
+ * });
1268
+ */
1269
+ export declare function useDeleteKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteKnowledgeBaseArticleMutation, Types.DeleteKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
1270
+ export type DeleteKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useDeleteKnowledgeBaseArticleMutation>;
1271
+ export type DeleteKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.DeleteKnowledgeBaseArticleMutation>;
1272
+ export type DeleteKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.DeleteKnowledgeBaseArticleMutation, Types.DeleteKnowledgeBaseArticleMutationVariables>;
1273
+ export declare const DeleteTicketCategoryDocument: Apollo.DocumentNode;
1274
+ export type DeleteTicketCategoryMutationFn = Apollo.MutationFunction<Types.DeleteTicketCategoryMutation, Types.DeleteTicketCategoryMutationVariables>;
1275
+ /**
1276
+ * __useDeleteTicketCategoryMutation__
1277
+ *
1278
+ * To run a mutation, you first call `useDeleteTicketCategoryMutation` within a React component and pass it any options that fit your needs.
1279
+ * When your component renders, `useDeleteTicketCategoryMutation` returns a tuple that includes:
1280
+ * - A mutate function that you can call at any time to execute the mutation
1281
+ * - An object with fields that represent the current status of the mutation's execution
1282
+ *
1283
+ * @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;
1284
+ *
1285
+ * @example
1286
+ * const [deleteTicketCategoryMutation, { data, loading, error }] = useDeleteTicketCategoryMutation({
1287
+ * variables: {
1288
+ * id: // value for 'id'
1289
+ * },
1290
+ * });
1291
+ */
1292
+ export declare function useDeleteTicketCategoryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteTicketCategoryMutation, Types.DeleteTicketCategoryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteTicketCategoryMutation, any, Apollo.ApolloCache, undefined>;
1293
+ export type DeleteTicketCategoryMutationHookResult = ReturnType<typeof useDeleteTicketCategoryMutation>;
1294
+ export type DeleteTicketCategoryMutationResult = Apollo.MutationResult<Types.DeleteTicketCategoryMutation>;
1295
+ export type DeleteTicketCategoryMutationOptions = Apollo.BaseMutationOptions<Types.DeleteTicketCategoryMutation, Types.DeleteTicketCategoryMutationVariables>;
1296
+ export declare const PublishKnowledgeBaseArticleDocument: Apollo.DocumentNode;
1297
+ export type PublishKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.PublishKnowledgeBaseArticleMutation, Types.PublishKnowledgeBaseArticleMutationVariables>;
1298
+ /**
1299
+ * __usePublishKnowledgeBaseArticleMutation__
1300
+ *
1301
+ * To run a mutation, you first call `usePublishKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
1302
+ * When your component renders, `usePublishKnowledgeBaseArticleMutation` returns a tuple that includes:
1303
+ * - A mutate function that you can call at any time to execute the mutation
1304
+ * - An object with fields that represent the current status of the mutation's execution
1305
+ *
1306
+ * @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;
1307
+ *
1308
+ * @example
1309
+ * const [publishKnowledgeBaseArticleMutation, { data, loading, error }] = usePublishKnowledgeBaseArticleMutation({
1310
+ * variables: {
1311
+ * id: // value for 'id'
1312
+ * },
1313
+ * });
1314
+ */
1315
+ export declare function usePublishKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.PublishKnowledgeBaseArticleMutation, Types.PublishKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.PublishKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
1316
+ export type PublishKnowledgeBaseArticleMutationHookResult = ReturnType<typeof usePublishKnowledgeBaseArticleMutation>;
1317
+ export type PublishKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.PublishKnowledgeBaseArticleMutation>;
1318
+ export type PublishKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.PublishKnowledgeBaseArticleMutation, Types.PublishKnowledgeBaseArticleMutationVariables>;
1319
+ export declare const UnpublishKnowledgeBaseArticleDocument: Apollo.DocumentNode;
1320
+ export type UnpublishKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.UnpublishKnowledgeBaseArticleMutation, Types.UnpublishKnowledgeBaseArticleMutationVariables>;
1321
+ /**
1322
+ * __useUnpublishKnowledgeBaseArticleMutation__
1323
+ *
1324
+ * To run a mutation, you first call `useUnpublishKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
1325
+ * When your component renders, `useUnpublishKnowledgeBaseArticleMutation` returns a tuple that includes:
1326
+ * - A mutate function that you can call at any time to execute the mutation
1327
+ * - An object with fields that represent the current status of the mutation's execution
1328
+ *
1329
+ * @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;
1330
+ *
1331
+ * @example
1332
+ * const [unpublishKnowledgeBaseArticleMutation, { data, loading, error }] = useUnpublishKnowledgeBaseArticleMutation({
1333
+ * variables: {
1334
+ * id: // value for 'id'
1335
+ * },
1336
+ * });
1337
+ */
1338
+ export declare function useUnpublishKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UnpublishKnowledgeBaseArticleMutation, Types.UnpublishKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UnpublishKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
1339
+ export type UnpublishKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useUnpublishKnowledgeBaseArticleMutation>;
1340
+ export type UnpublishKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.UnpublishKnowledgeBaseArticleMutation>;
1341
+ export type UnpublishKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.UnpublishKnowledgeBaseArticleMutation, Types.UnpublishKnowledgeBaseArticleMutationVariables>;
1342
+ export declare const UpdateKnowledgeBaseArticleDocument: Apollo.DocumentNode;
1343
+ export type UpdateKnowledgeBaseArticleMutationFn = Apollo.MutationFunction<Types.UpdateKnowledgeBaseArticleMutation, Types.UpdateKnowledgeBaseArticleMutationVariables>;
1344
+ /**
1345
+ * __useUpdateKnowledgeBaseArticleMutation__
1346
+ *
1347
+ * To run a mutation, you first call `useUpdateKnowledgeBaseArticleMutation` within a React component and pass it any options that fit your needs.
1348
+ * When your component renders, `useUpdateKnowledgeBaseArticleMutation` returns a tuple that includes:
1349
+ * - A mutate function that you can call at any time to execute the mutation
1350
+ * - An object with fields that represent the current status of the mutation's execution
1351
+ *
1352
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
1353
+ *
1354
+ * @example
1355
+ * const [updateKnowledgeBaseArticleMutation, { data, loading, error }] = useUpdateKnowledgeBaseArticleMutation({
1356
+ * variables: {
1357
+ * id: // value for 'id'
1358
+ * input: // value for 'input'
1359
+ * },
1360
+ * });
1361
+ */
1362
+ export declare function useUpdateKnowledgeBaseArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateKnowledgeBaseArticleMutation, Types.UpdateKnowledgeBaseArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateKnowledgeBaseArticleMutation, any, Apollo.ApolloCache, undefined>;
1363
+ export type UpdateKnowledgeBaseArticleMutationHookResult = ReturnType<typeof useUpdateKnowledgeBaseArticleMutation>;
1364
+ export type UpdateKnowledgeBaseArticleMutationResult = Apollo.MutationResult<Types.UpdateKnowledgeBaseArticleMutation>;
1365
+ export type UpdateKnowledgeBaseArticleMutationOptions = Apollo.BaseMutationOptions<Types.UpdateKnowledgeBaseArticleMutation, Types.UpdateKnowledgeBaseArticleMutationVariables>;
1366
+ export declare const UpdateTicketCategoryDocument: Apollo.DocumentNode;
1367
+ export type UpdateTicketCategoryMutationFn = Apollo.MutationFunction<Types.UpdateTicketCategoryMutation, Types.UpdateTicketCategoryMutationVariables>;
1368
+ /**
1369
+ * __useUpdateTicketCategoryMutation__
1370
+ *
1371
+ * To run a mutation, you first call `useUpdateTicketCategoryMutation` within a React component and pass it any options that fit your needs.
1372
+ * When your component renders, `useUpdateTicketCategoryMutation` returns a tuple that includes:
1373
+ * - A mutate function that you can call at any time to execute the mutation
1374
+ * - An object with fields that represent the current status of the mutation's execution
1375
+ *
1376
+ * @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;
1377
+ *
1378
+ * @example
1379
+ * const [updateTicketCategoryMutation, { data, loading, error }] = useUpdateTicketCategoryMutation({
1380
+ * variables: {
1381
+ * id: // value for 'id'
1382
+ * input: // value for 'input'
1383
+ * },
1384
+ * });
1385
+ */
1386
+ export declare function useUpdateTicketCategoryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateTicketCategoryMutation, Types.UpdateTicketCategoryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateTicketCategoryMutation, any, Apollo.ApolloCache, undefined>;
1387
+ export type UpdateTicketCategoryMutationHookResult = ReturnType<typeof useUpdateTicketCategoryMutation>;
1388
+ export type UpdateTicketCategoryMutationResult = Apollo.MutationResult<Types.UpdateTicketCategoryMutation>;
1389
+ export type UpdateTicketCategoryMutationOptions = Apollo.BaseMutationOptions<Types.UpdateTicketCategoryMutation, Types.UpdateTicketCategoryMutationVariables>;
1390
+ export declare const CreateSupportMessageDocument: Apollo.DocumentNode;
1391
+ export type CreateSupportMessageMutationFn = Apollo.MutationFunction<Types.CreateSupportMessageMutation, Types.CreateSupportMessageMutationVariables>;
1392
+ /**
1393
+ * __useCreateSupportMessageMutation__
1394
+ *
1395
+ * To run a mutation, you first call `useCreateSupportMessageMutation` within a React component and pass it any options that fit your needs.
1396
+ * When your component renders, `useCreateSupportMessageMutation` returns a tuple that includes:
1397
+ * - A mutate function that you can call at any time to execute the mutation
1398
+ * - An object with fields that represent the current status of the mutation's execution
1399
+ *
1400
+ * @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;
1401
+ *
1402
+ * @example
1403
+ * const [createSupportMessageMutation, { data, loading, error }] = useCreateSupportMessageMutation({
1404
+ * variables: {
1405
+ * input: // value for 'input'
1406
+ * },
1407
+ * });
1408
+ */
1409
+ export declare function useCreateSupportMessageMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSupportMessageMutation, Types.CreateSupportMessageMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSupportMessageMutation, any, Apollo.ApolloCache, undefined>;
1410
+ export type CreateSupportMessageMutationHookResult = ReturnType<typeof useCreateSupportMessageMutation>;
1411
+ export type CreateSupportMessageMutationResult = Apollo.MutationResult<Types.CreateSupportMessageMutation>;
1412
+ export type CreateSupportMessageMutationOptions = Apollo.BaseMutationOptions<Types.CreateSupportMessageMutation, Types.CreateSupportMessageMutationVariables>;
1413
+ export declare const AssignSupportTicketDocument: Apollo.DocumentNode;
1414
+ export type AssignSupportTicketMutationFn = Apollo.MutationFunction<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>;
1415
+ /**
1416
+ * __useAssignSupportTicketMutation__
1417
+ *
1418
+ * To run a mutation, you first call `useAssignSupportTicketMutation` within a React component and pass it any options that fit your needs.
1419
+ * When your component renders, `useAssignSupportTicketMutation` returns a tuple that includes:
1420
+ * - A mutate function that you can call at any time to execute the mutation
1421
+ * - An object with fields that represent the current status of the mutation's execution
1422
+ *
1423
+ * @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;
1424
+ *
1425
+ * @example
1426
+ * const [assignSupportTicketMutation, { data, loading, error }] = useAssignSupportTicketMutation({
1427
+ * variables: {
1428
+ * id: // value for 'id'
1429
+ * assignedTo: // value for 'assignedTo'
1430
+ * },
1431
+ * });
1432
+ */
1433
+ export declare function useAssignSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.AssignSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
1434
+ export type AssignSupportTicketMutationHookResult = ReturnType<typeof useAssignSupportTicketMutation>;
1435
+ export type AssignSupportTicketMutationResult = Apollo.MutationResult<Types.AssignSupportTicketMutation>;
1436
+ export type AssignSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.AssignSupportTicketMutation, Types.AssignSupportTicketMutationVariables>;
1437
+ export declare const UpdateSupportTicketStatusDocument: Apollo.DocumentNode;
1438
+ export type UpdateSupportTicketStatusMutationFn = Apollo.MutationFunction<Types.UpdateSupportTicketStatusMutation, Types.UpdateSupportTicketStatusMutationVariables>;
1439
+ /**
1440
+ * __useUpdateSupportTicketStatusMutation__
1441
+ *
1442
+ * To run a mutation, you first call `useUpdateSupportTicketStatusMutation` within a React component and pass it any options that fit your needs.
1443
+ * When your component renders, `useUpdateSupportTicketStatusMutation` returns a tuple that includes:
1444
+ * - A mutate function that you can call at any time to execute the mutation
1445
+ * - An object with fields that represent the current status of the mutation's execution
1446
+ *
1447
+ * @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;
1448
+ *
1449
+ * @example
1450
+ * const [updateSupportTicketStatusMutation, { data, loading, error }] = useUpdateSupportTicketStatusMutation({
1451
+ * variables: {
1452
+ * id: // value for 'id'
1453
+ * status: // value for 'status'
1454
+ * },
1455
+ * });
1456
+ */
1457
+ export declare function useUpdateSupportTicketStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateSupportTicketStatusMutation, Types.UpdateSupportTicketStatusMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateSupportTicketStatusMutation, any, Apollo.ApolloCache, undefined>;
1458
+ export type UpdateSupportTicketStatusMutationHookResult = ReturnType<typeof useUpdateSupportTicketStatusMutation>;
1459
+ export type UpdateSupportTicketStatusMutationResult = Apollo.MutationResult<Types.UpdateSupportTicketStatusMutation>;
1460
+ export type UpdateSupportTicketStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateSupportTicketStatusMutation, Types.UpdateSupportTicketStatusMutationVariables>;
1461
+ export declare const CloseSupportTicketDocument: Apollo.DocumentNode;
1462
+ export type CloseSupportTicketMutationFn = Apollo.MutationFunction<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>;
1463
+ /**
1464
+ * __useCloseSupportTicketMutation__
1465
+ *
1466
+ * To run a mutation, you first call `useCloseSupportTicketMutation` within a React component and pass it any options that fit your needs.
1467
+ * When your component renders, `useCloseSupportTicketMutation` returns a tuple that includes:
1468
+ * - A mutate function that you can call at any time to execute the mutation
1469
+ * - An object with fields that represent the current status of the mutation's execution
1470
+ *
1471
+ * @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;
1472
+ *
1473
+ * @example
1474
+ * const [closeSupportTicketMutation, { data, loading, error }] = useCloseSupportTicketMutation({
1475
+ * variables: {
1476
+ * id: // value for 'id'
1477
+ * },
1478
+ * });
1479
+ */
1480
+ export declare function useCloseSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CloseSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
1481
+ export type CloseSupportTicketMutationHookResult = ReturnType<typeof useCloseSupportTicketMutation>;
1482
+ export type CloseSupportTicketMutationResult = Apollo.MutationResult<Types.CloseSupportTicketMutation>;
1483
+ export type CloseSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.CloseSupportTicketMutation, Types.CloseSupportTicketMutationVariables>;
1484
+ export declare const CreateCannedResponseDocument: Apollo.DocumentNode;
1485
+ export type CreateCannedResponseMutationFn = Apollo.MutationFunction<Types.CreateCannedResponseMutation, Types.CreateCannedResponseMutationVariables>;
1486
+ /**
1487
+ * __useCreateCannedResponseMutation__
1488
+ *
1489
+ * To run a mutation, you first call `useCreateCannedResponseMutation` within a React component and pass it any options that fit your needs.
1490
+ * When your component renders, `useCreateCannedResponseMutation` returns a tuple that includes:
1491
+ * - A mutate function that you can call at any time to execute the mutation
1492
+ * - An object with fields that represent the current status of the mutation's execution
1493
+ *
1494
+ * @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;
1495
+ *
1496
+ * @example
1497
+ * const [createCannedResponseMutation, { data, loading, error }] = useCreateCannedResponseMutation({
1498
+ * variables: {
1499
+ * input: // value for 'input'
1500
+ * },
1501
+ * });
1502
+ */
1503
+ export declare function useCreateCannedResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateCannedResponseMutation, Types.CreateCannedResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateCannedResponseMutation, any, Apollo.ApolloCache, undefined>;
1504
+ export type CreateCannedResponseMutationHookResult = ReturnType<typeof useCreateCannedResponseMutation>;
1505
+ export type CreateCannedResponseMutationResult = Apollo.MutationResult<Types.CreateCannedResponseMutation>;
1506
+ export type CreateCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.CreateCannedResponseMutation, Types.CreateCannedResponseMutationVariables>;
1507
+ export declare const CreateSlaPolicyDocument: Apollo.DocumentNode;
1508
+ export type CreateSlaPolicyMutationFn = Apollo.MutationFunction<Types.CreateSlaPolicyMutation, Types.CreateSlaPolicyMutationVariables>;
1509
+ /**
1510
+ * __useCreateSlaPolicyMutation__
1511
+ *
1512
+ * To run a mutation, you first call `useCreateSlaPolicyMutation` within a React component and pass it any options that fit your needs.
1513
+ * When your component renders, `useCreateSlaPolicyMutation` returns a tuple that includes:
1514
+ * - A mutate function that you can call at any time to execute the mutation
1515
+ * - An object with fields that represent the current status of the mutation's execution
1516
+ *
1517
+ * @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;
1518
+ *
1519
+ * @example
1520
+ * const [createSlaPolicyMutation, { data, loading, error }] = useCreateSlaPolicyMutation({
1521
+ * variables: {
1522
+ * input: // value for 'input'
1523
+ * },
1524
+ * });
1525
+ */
1526
+ export declare function useCreateSlaPolicyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.CreateSlaPolicyMutation, Types.CreateSlaPolicyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.CreateSlaPolicyMutation, any, Apollo.ApolloCache, undefined>;
1527
+ export type CreateSlaPolicyMutationHookResult = ReturnType<typeof useCreateSlaPolicyMutation>;
1528
+ export type CreateSlaPolicyMutationResult = Apollo.MutationResult<Types.CreateSlaPolicyMutation>;
1529
+ export type CreateSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.CreateSlaPolicyMutation, Types.CreateSlaPolicyMutationVariables>;
1530
+ export declare const CreateSupportTicketDocument: Apollo.DocumentNode;
1531
+ export type CreateSupportTicketMutationFn = Apollo.MutationFunction<Types.CreateSupportTicketMutation, Types.CreateSupportTicketMutationVariables>;
1532
+ /**
1533
+ * __useCreateSupportTicketMutation__
1534
+ *
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:
1537
+ * - A mutate function that you can call at any time to execute the mutation
1538
+ * - An object with fields that represent the current status of the mutation's execution
1539
+ *
1540
+ * @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
+ *
1542
+ * @example
1543
+ * const [createSupportTicketMutation, { data, loading, error }] = useCreateSupportTicketMutation({
1544
+ * variables: {
1545
+ * input: // value for 'input'
1546
+ * },
1547
+ * });
1548
+ */
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>;
1555
+ /**
1556
+ * __useDeleteCannedResponseMutation__
1557
+ *
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:
1560
+ * - A mutate function that you can call at any time to execute the mutation
1561
+ * - An object with fields that represent the current status of the mutation's execution
1562
+ *
1563
+ * @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
+ *
1565
+ * @example
1566
+ * const [deleteCannedResponseMutation, { data, loading, error }] = useDeleteCannedResponseMutation({
1567
+ * variables: {
1568
+ * id: // value for 'id'
1569
+ * },
1570
+ * });
1571
+ */
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>;
1576
+ export declare const DeleteSlaPolicyDocument: Apollo.DocumentNode;
1577
+ export type DeleteSlaPolicyMutationFn = Apollo.MutationFunction<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>;
1578
+ /**
1579
+ * __useDeleteSlaPolicyMutation__
1580
+ *
1581
+ * To run a mutation, you first call `useDeleteSlaPolicyMutation` within a React component and pass it any options that fit your needs.
1582
+ * When your component renders, `useDeleteSlaPolicyMutation` returns a tuple that includes:
1583
+ * - A mutate function that you can call at any time to execute the mutation
1584
+ * - An object with fields that represent the current status of the mutation's execution
1585
+ *
1586
+ * @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;
1587
+ *
1588
+ * @example
1589
+ * const [deleteSlaPolicyMutation, { data, loading, error }] = useDeleteSlaPolicyMutation({
1590
+ * variables: {
1591
+ * id: // value for 'id'
1592
+ * },
1593
+ * });
1594
+ */
1595
+ export declare function useDeleteSlaPolicyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.DeleteSlaPolicyMutation, any, Apollo.ApolloCache, undefined>;
1596
+ export type DeleteSlaPolicyMutationHookResult = ReturnType<typeof useDeleteSlaPolicyMutation>;
1597
+ export type DeleteSlaPolicyMutationResult = Apollo.MutationResult<Types.DeleteSlaPolicyMutation>;
1598
+ export type DeleteSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.DeleteSlaPolicyMutation, Types.DeleteSlaPolicyMutationVariables>;
1599
+ export declare const RateArticleDocument: Apollo.DocumentNode;
1600
+ export type RateArticleMutationFn = Apollo.MutationFunction<Types.RateArticleMutation, Types.RateArticleMutationVariables>;
1601
+ /**
1602
+ * __useRateArticleMutation__
1603
+ *
1604
+ * To run a mutation, you first call `useRateArticleMutation` within a React component and pass it any options that fit your needs.
1605
+ * When your component renders, `useRateArticleMutation` returns a tuple that includes:
1606
+ * - A mutate function that you can call at any time to execute the mutation
1607
+ * - An object with fields that represent the current status of the mutation's execution
1608
+ *
1609
+ * @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;
1610
+ *
1611
+ * @example
1612
+ * const [rateArticleMutation, { data, loading, error }] = useRateArticleMutation({
1613
+ * variables: {
1614
+ * id: // value for 'id'
1615
+ * helpful: // value for 'helpful'
1616
+ * },
1617
+ * });
1618
+ */
1619
+ export declare function useRateArticleMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RateArticleMutation, Types.RateArticleMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RateArticleMutation, any, Apollo.ApolloCache, undefined>;
1620
+ export type RateArticleMutationHookResult = ReturnType<typeof useRateArticleMutation>;
1621
+ export type RateArticleMutationResult = Apollo.MutationResult<Types.RateArticleMutation>;
1622
+ export type RateArticleMutationOptions = Apollo.BaseMutationOptions<Types.RateArticleMutation, Types.RateArticleMutationVariables>;
1623
+ export declare const RecordArticleViewDocument: Apollo.DocumentNode;
1624
+ export type RecordArticleViewMutationFn = Apollo.MutationFunction<Types.RecordArticleViewMutation, Types.RecordArticleViewMutationVariables>;
1625
+ /**
1626
+ * __useRecordArticleViewMutation__
1627
+ *
1628
+ * To run a mutation, you first call `useRecordArticleViewMutation` within a React component and pass it any options that fit your needs.
1629
+ * When your component renders, `useRecordArticleViewMutation` returns a tuple that includes:
1630
+ * - A mutate function that you can call at any time to execute the mutation
1631
+ * - An object with fields that represent the current status of the mutation's execution
1632
+ *
1633
+ * @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;
1634
+ *
1635
+ * @example
1636
+ * const [recordArticleViewMutation, { data, loading, error }] = useRecordArticleViewMutation({
1637
+ * variables: {
1638
+ * id: // value for 'id'
1639
+ * },
1640
+ * });
1641
+ */
1642
+ export declare function useRecordArticleViewMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.RecordArticleViewMutation, Types.RecordArticleViewMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.RecordArticleViewMutation, any, Apollo.ApolloCache, undefined>;
1643
+ export type RecordArticleViewMutationHookResult = ReturnType<typeof useRecordArticleViewMutation>;
1644
+ export type RecordArticleViewMutationResult = Apollo.MutationResult<Types.RecordArticleViewMutation>;
1645
+ export type RecordArticleViewMutationOptions = Apollo.BaseMutationOptions<Types.RecordArticleViewMutation, Types.RecordArticleViewMutationVariables>;
1646
+ export declare const ReplyToContactInquiryDocument: Apollo.DocumentNode;
1647
+ export type ReplyToContactInquiryMutationFn = Apollo.MutationFunction<Types.ReplyToContactInquiryMutation, Types.ReplyToContactInquiryMutationVariables>;
1648
+ /**
1649
+ * __useReplyToContactInquiryMutation__
1650
+ *
1651
+ * To run a mutation, you first call `useReplyToContactInquiryMutation` within a React component and pass it any options that fit your needs.
1652
+ * When your component renders, `useReplyToContactInquiryMutation` returns a tuple that includes:
1653
+ * - A mutate function that you can call at any time to execute the mutation
1654
+ * - An object with fields that represent the current status of the mutation's execution
1655
+ *
1656
+ * @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;
1657
+ *
1658
+ * @example
1659
+ * const [replyToContactInquiryMutation, { data, loading, error }] = useReplyToContactInquiryMutation({
1660
+ * variables: {
1661
+ * id: // value for 'id'
1662
+ * message: // value for 'message'
1663
+ * },
1664
+ * });
1665
+ */
1666
+ export declare function useReplyToContactInquiryMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReplyToContactInquiryMutation, Types.ReplyToContactInquiryMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReplyToContactInquiryMutation, any, Apollo.ApolloCache, undefined>;
1667
+ export type ReplyToContactInquiryMutationHookResult = ReturnType<typeof useReplyToContactInquiryMutation>;
1668
+ export type ReplyToContactInquiryMutationResult = Apollo.MutationResult<Types.ReplyToContactInquiryMutation>;
1669
+ export type ReplyToContactInquiryMutationOptions = Apollo.BaseMutationOptions<Types.ReplyToContactInquiryMutation, Types.ReplyToContactInquiryMutationVariables>;
1670
+ export declare const ReplyToJobApplicationDocument: Apollo.DocumentNode;
1671
+ export type ReplyToJobApplicationMutationFn = Apollo.MutationFunction<Types.ReplyToJobApplicationMutation, Types.ReplyToJobApplicationMutationVariables>;
1672
+ /**
1673
+ * __useReplyToJobApplicationMutation__
1674
+ *
1675
+ * To run a mutation, you first call `useReplyToJobApplicationMutation` within a React component and pass it any options that fit your needs.
1676
+ * When your component renders, `useReplyToJobApplicationMutation` returns a tuple that includes:
1677
+ * - A mutate function that you can call at any time to execute the mutation
1678
+ * - An object with fields that represent the current status of the mutation's execution
1679
+ *
1680
+ * @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;
1681
+ *
1682
+ * @example
1683
+ * const [replyToJobApplicationMutation, { data, loading, error }] = useReplyToJobApplicationMutation({
1684
+ * variables: {
1685
+ * id: // value for 'id'
1686
+ * message: // value for 'message'
1687
+ * },
1688
+ * });
1689
+ */
1690
+ export declare function useReplyToJobApplicationMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ReplyToJobApplicationMutation, Types.ReplyToJobApplicationMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ReplyToJobApplicationMutation, any, Apollo.ApolloCache, undefined>;
1691
+ export type ReplyToJobApplicationMutationHookResult = ReturnType<typeof useReplyToJobApplicationMutation>;
1692
+ export type ReplyToJobApplicationMutationResult = Apollo.MutationResult<Types.ReplyToJobApplicationMutation>;
1693
+ export type ReplyToJobApplicationMutationOptions = Apollo.BaseMutationOptions<Types.ReplyToJobApplicationMutation, Types.ReplyToJobApplicationMutationVariables>;
1694
+ export declare const ResolveSupportTicketDocument: Apollo.DocumentNode;
1695
+ export type ResolveSupportTicketMutationFn = Apollo.MutationFunction<Types.ResolveSupportTicketMutation, Types.ResolveSupportTicketMutationVariables>;
1696
+ /**
1697
+ * __useResolveSupportTicketMutation__
1698
+ *
1699
+ * To run a mutation, you first call `useResolveSupportTicketMutation` within a React component and pass it any options that fit your needs.
1700
+ * When your component renders, `useResolveSupportTicketMutation` returns a tuple that includes:
1701
+ * - A mutate function that you can call at any time to execute the mutation
1702
+ * - An object with fields that represent the current status of the mutation's execution
1703
+ *
1704
+ * @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;
1705
+ *
1706
+ * @example
1707
+ * const [resolveSupportTicketMutation, { data, loading, error }] = useResolveSupportTicketMutation({
1708
+ * variables: {
1709
+ * id: // value for 'id'
1710
+ * resolution: // value for 'resolution'
1711
+ * },
1712
+ * });
1713
+ */
1714
+ export declare function useResolveSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.ResolveSupportTicketMutation, Types.ResolveSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.ResolveSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
1715
+ export type ResolveSupportTicketMutationHookResult = ReturnType<typeof useResolveSupportTicketMutation>;
1716
+ export type ResolveSupportTicketMutationResult = Apollo.MutationResult<Types.ResolveSupportTicketMutation>;
1717
+ export type ResolveSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.ResolveSupportTicketMutation, Types.ResolveSupportTicketMutationVariables>;
1718
+ export declare const SubmitSatisfactionSurveyDocument: Apollo.DocumentNode;
1719
+ export type SubmitSatisfactionSurveyMutationFn = Apollo.MutationFunction<Types.SubmitSatisfactionSurveyMutation, Types.SubmitSatisfactionSurveyMutationVariables>;
1720
+ /**
1721
+ * __useSubmitSatisfactionSurveyMutation__
1722
+ *
1723
+ * To run a mutation, you first call `useSubmitSatisfactionSurveyMutation` within a React component and pass it any options that fit your needs.
1724
+ * When your component renders, `useSubmitSatisfactionSurveyMutation` returns a tuple that includes:
1725
+ * - A mutate function that you can call at any time to execute the mutation
1726
+ * - An object with fields that represent the current status of the mutation's execution
1727
+ *
1728
+ * @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;
1729
+ *
1730
+ * @example
1731
+ * const [submitSatisfactionSurveyMutation, { data, loading, error }] = useSubmitSatisfactionSurveyMutation({
1732
+ * variables: {
1733
+ * input: // value for 'input'
1734
+ * },
1735
+ * });
1736
+ */
1737
+ export declare function useSubmitSatisfactionSurveyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.SubmitSatisfactionSurveyMutation, Types.SubmitSatisfactionSurveyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.SubmitSatisfactionSurveyMutation, any, Apollo.ApolloCache, undefined>;
1738
+ export type SubmitSatisfactionSurveyMutationHookResult = ReturnType<typeof useSubmitSatisfactionSurveyMutation>;
1739
+ export type SubmitSatisfactionSurveyMutationResult = Apollo.MutationResult<Types.SubmitSatisfactionSurveyMutation>;
1740
+ export type SubmitSatisfactionSurveyMutationOptions = Apollo.BaseMutationOptions<Types.SubmitSatisfactionSurveyMutation, Types.SubmitSatisfactionSurveyMutationVariables>;
1741
+ export declare const UpdateCannedResponseDocument: Apollo.DocumentNode;
1742
+ export type UpdateCannedResponseMutationFn = Apollo.MutationFunction<Types.UpdateCannedResponseMutation, Types.UpdateCannedResponseMutationVariables>;
1743
+ /**
1744
+ * __useUpdateCannedResponseMutation__
1745
+ *
1746
+ * To run a mutation, you first call `useUpdateCannedResponseMutation` within a React component and pass it any options that fit your needs.
1747
+ * When your component renders, `useUpdateCannedResponseMutation` returns a tuple that includes:
1748
+ * - A mutate function that you can call at any time to execute the mutation
1749
+ * - An object with fields that represent the current status of the mutation's execution
1750
+ *
1751
+ * @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;
1752
+ *
1753
+ * @example
1754
+ * const [updateCannedResponseMutation, { data, loading, error }] = useUpdateCannedResponseMutation({
1755
+ * variables: {
1756
+ * id: // value for 'id'
1757
+ * input: // value for 'input'
1758
+ * },
1759
+ * });
1760
+ */
1761
+ export declare function useUpdateCannedResponseMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateCannedResponseMutation, Types.UpdateCannedResponseMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateCannedResponseMutation, any, Apollo.ApolloCache, undefined>;
1762
+ export type UpdateCannedResponseMutationHookResult = ReturnType<typeof useUpdateCannedResponseMutation>;
1763
+ export type UpdateCannedResponseMutationResult = Apollo.MutationResult<Types.UpdateCannedResponseMutation>;
1764
+ export type UpdateCannedResponseMutationOptions = Apollo.BaseMutationOptions<Types.UpdateCannedResponseMutation, Types.UpdateCannedResponseMutationVariables>;
1765
+ export declare const UpdateContactInquiryStatusDocument: Apollo.DocumentNode;
1766
+ export type UpdateContactInquiryStatusMutationFn = Apollo.MutationFunction<Types.UpdateContactInquiryStatusMutation, Types.UpdateContactInquiryStatusMutationVariables>;
1767
+ /**
1768
+ * __useUpdateContactInquiryStatusMutation__
1769
+ *
1770
+ * To run a mutation, you first call `useUpdateContactInquiryStatusMutation` within a React component and pass it any options that fit your needs.
1771
+ * When your component renders, `useUpdateContactInquiryStatusMutation` returns a tuple that includes:
1772
+ * - A mutate function that you can call at any time to execute the mutation
1773
+ * - An object with fields that represent the current status of the mutation's execution
1774
+ *
1775
+ * @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;
1776
+ *
1777
+ * @example
1778
+ * const [updateContactInquiryStatusMutation, { data, loading, error }] = useUpdateContactInquiryStatusMutation({
1779
+ * variables: {
1780
+ * id: // value for 'id'
1781
+ * input: // value for 'input'
1782
+ * },
1783
+ * });
1784
+ */
1785
+ export declare function useUpdateContactInquiryStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateContactInquiryStatusMutation, Types.UpdateContactInquiryStatusMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateContactInquiryStatusMutation, any, Apollo.ApolloCache, undefined>;
1786
+ export type UpdateContactInquiryStatusMutationHookResult = ReturnType<typeof useUpdateContactInquiryStatusMutation>;
1787
+ export type UpdateContactInquiryStatusMutationResult = Apollo.MutationResult<Types.UpdateContactInquiryStatusMutation>;
1788
+ export type UpdateContactInquiryStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateContactInquiryStatusMutation, Types.UpdateContactInquiryStatusMutationVariables>;
1789
+ export declare const UpdateJobApplicationStatusDocument: Apollo.DocumentNode;
1790
+ export type UpdateJobApplicationStatusMutationFn = Apollo.MutationFunction<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>;
1791
+ /**
1792
+ * __useUpdateJobApplicationStatusMutation__
1793
+ *
1794
+ * To run a mutation, you first call `useUpdateJobApplicationStatusMutation` within a React component and pass it any options that fit your needs.
1795
+ * When your component renders, `useUpdateJobApplicationStatusMutation` returns a tuple that includes:
1796
+ * - A mutate function that you can call at any time to execute the mutation
1797
+ * - An object with fields that represent the current status of the mutation's execution
1798
+ *
1799
+ * @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;
1800
+ *
1801
+ * @example
1802
+ * const [updateJobApplicationStatusMutation, { data, loading, error }] = useUpdateJobApplicationStatusMutation({
1803
+ * variables: {
1804
+ * id: // value for 'id'
1805
+ * input: // value for 'input'
1806
+ * },
1807
+ * });
1808
+ */
1809
+ export declare function useUpdateJobApplicationStatusMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateJobApplicationStatusMutation, any, Apollo.ApolloCache, undefined>;
1810
+ export type UpdateJobApplicationStatusMutationHookResult = ReturnType<typeof useUpdateJobApplicationStatusMutation>;
1811
+ export type UpdateJobApplicationStatusMutationResult = Apollo.MutationResult<Types.UpdateJobApplicationStatusMutation>;
1812
+ export type UpdateJobApplicationStatusMutationOptions = Apollo.BaseMutationOptions<Types.UpdateJobApplicationStatusMutation, Types.UpdateJobApplicationStatusMutationVariables>;
1813
+ export declare const UpdateSlaPolicyDocument: Apollo.DocumentNode;
1814
+ export type UpdateSlaPolicyMutationFn = Apollo.MutationFunction<Types.UpdateSlaPolicyMutation, Types.UpdateSlaPolicyMutationVariables>;
1815
+ /**
1816
+ * __useUpdateSlaPolicyMutation__
1817
+ *
1818
+ * To run a mutation, you first call `useUpdateSlaPolicyMutation` within a React component and pass it any options that fit your needs.
1819
+ * When your component renders, `useUpdateSlaPolicyMutation` returns a tuple that includes:
1820
+ * - A mutate function that you can call at any time to execute the mutation
1821
+ * - An object with fields that represent the current status of the mutation's execution
1822
+ *
1823
+ * @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;
1824
+ *
1825
+ * @example
1826
+ * const [updateSlaPolicyMutation, { data, loading, error }] = useUpdateSlaPolicyMutation({
1827
+ * variables: {
1828
+ * id: // value for 'id'
1829
+ * input: // value for 'input'
1830
+ * },
1831
+ * });
1832
+ */
1833
+ export declare function useUpdateSlaPolicyMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateSlaPolicyMutation, Types.UpdateSlaPolicyMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateSlaPolicyMutation, any, Apollo.ApolloCache, undefined>;
1834
+ export type UpdateSlaPolicyMutationHookResult = ReturnType<typeof useUpdateSlaPolicyMutation>;
1835
+ export type UpdateSlaPolicyMutationResult = Apollo.MutationResult<Types.UpdateSlaPolicyMutation>;
1836
+ export type UpdateSlaPolicyMutationOptions = Apollo.BaseMutationOptions<Types.UpdateSlaPolicyMutation, Types.UpdateSlaPolicyMutationVariables>;
1837
+ export declare const UpdateSupportTicketDocument: Apollo.DocumentNode;
1838
+ export type UpdateSupportTicketMutationFn = Apollo.MutationFunction<Types.UpdateSupportTicketMutation, Types.UpdateSupportTicketMutationVariables>;
1839
+ /**
1840
+ * __useUpdateSupportTicketMutation__
1841
+ *
1842
+ * To run a mutation, you first call `useUpdateSupportTicketMutation` within a React component and pass it any options that fit your needs.
1843
+ * When your component renders, `useUpdateSupportTicketMutation` returns a tuple that includes:
1844
+ * - A mutate function that you can call at any time to execute the mutation
1845
+ * - An object with fields that represent the current status of the mutation's execution
1846
+ *
1847
+ * @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;
1848
+ *
1849
+ * @example
1850
+ * const [updateSupportTicketMutation, { data, loading, error }] = useUpdateSupportTicketMutation({
1851
+ * variables: {
1852
+ * id: // value for 'id'
1853
+ * input: // value for 'input'
1854
+ * },
1855
+ * });
1856
+ */
1857
+ export declare function useUpdateSupportTicketMutation(baseOptions?: ApolloReactHooks.MutationHookOptions<Types.UpdateSupportTicketMutation, Types.UpdateSupportTicketMutationVariables>): ApolloReactHooks.useMutation.ResultTuple<Types.UpdateSupportTicketMutation, any, Apollo.ApolloCache, undefined>;
1858
+ export type UpdateSupportTicketMutationHookResult = ReturnType<typeof useUpdateSupportTicketMutation>;
1859
+ export type UpdateSupportTicketMutationResult = Apollo.MutationResult<Types.UpdateSupportTicketMutation>;
1860
+ export type UpdateSupportTicketMutationOptions = Apollo.BaseMutationOptions<Types.UpdateSupportTicketMutation, Types.UpdateSupportTicketMutationVariables>;
1861
+ export declare const GetAgentLeaderboardDocument: Apollo.DocumentNode;
1862
+ /**
1863
+ * __useGetAgentLeaderboardQuery__
1864
+ *
1865
+ * To run a query within a React component, call `useGetAgentLeaderboardQuery` and pass it any options that fit your needs.
1866
+ * When your component renders, `useGetAgentLeaderboardQuery` returns an object from Apollo Client that contains loading, error, and data properties
1867
+ * you can use to render your UI.
1868
+ *
1869
+ * @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;
1870
+ *
1871
+ * @example
1872
+ * const { data, loading, error } = useGetAgentLeaderboardQuery({
1873
+ * variables: {
1874
+ * period: // value for 'period'
1875
+ * limit: // value for 'limit'
1876
+ * },
1877
+ * });
1878
+ */
1879
+ export declare function useGetAgentLeaderboardQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables, "empty" | "complete" | "streaming", Types.GetAgentLeaderboardQueryVariables>;
1880
+ export declare function useGetAgentLeaderboardLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables, "empty" | "complete" | "streaming">;
1881
+ export declare function useGetAgentLeaderboardSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>;
1882
+ export declare function useGetAgentLeaderboardSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentLeaderboardQuery | undefined, Types.GetAgentLeaderboardQueryVariables>;
1883
+ export type GetAgentLeaderboardQueryHookResult = ReturnType<typeof useGetAgentLeaderboardQuery>;
1884
+ export type GetAgentLeaderboardLazyQueryHookResult = ReturnType<typeof useGetAgentLeaderboardLazyQuery>;
1885
+ export type GetAgentLeaderboardSuspenseQueryHookResult = ReturnType<typeof useGetAgentLeaderboardSuspenseQuery>;
1886
+ export type GetAgentLeaderboardQueryResult = Apollo.QueryResult<Types.GetAgentLeaderboardQuery, Types.GetAgentLeaderboardQueryVariables>;
1887
+ export declare const GetSlaReportDocument: Apollo.DocumentNode;
1888
+ /**
1889
+ * __useGetSlaReportQuery__
1890
+ *
1891
+ * To run a query within a React component, call `useGetSlaReportQuery` and pass it any options that fit your needs.
1892
+ * When your component renders, `useGetSlaReportQuery` returns an object from Apollo Client that contains loading, error, and data properties
1893
+ * you can use to render your UI.
1894
+ *
1895
+ * @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;
1896
+ *
1897
+ * @example
1898
+ * const { data, loading, error } = useGetSlaReportQuery({
1899
+ * variables: {
1900
+ * filter: // value for 'filter'
1901
+ * },
1902
+ * });
1903
+ */
1904
+ export declare function useGetSlaReportQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables, "empty" | "complete" | "streaming", Types.GetSlaReportQueryVariables>;
1905
+ export declare function useGetSlaReportLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables, "empty" | "complete" | "streaming">;
1906
+ export declare function useGetSlaReportSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>;
1907
+ export declare function useGetSlaReportSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaReportQuery | undefined, Types.GetSlaReportQueryVariables>;
1908
+ export type GetSlaReportQueryHookResult = ReturnType<typeof useGetSlaReportQuery>;
1909
+ export type GetSlaReportLazyQueryHookResult = ReturnType<typeof useGetSlaReportLazyQuery>;
1910
+ export type GetSlaReportSuspenseQueryHookResult = ReturnType<typeof useGetSlaReportSuspenseQuery>;
1911
+ export type GetSlaReportQueryResult = Apollo.QueryResult<Types.GetSlaReportQuery, Types.GetSlaReportQueryVariables>;
1912
+ export declare const GetSatisfactionMetricsDocument: Apollo.DocumentNode;
1913
+ /**
1914
+ * __useGetSatisfactionMetricsQuery__
1915
+ *
1916
+ * To run a query within a React component, call `useGetSatisfactionMetricsQuery` and pass it any options that fit your needs.
1917
+ * When your component renders, `useGetSatisfactionMetricsQuery` returns an object from Apollo Client that contains loading, error, and data properties
1918
+ * you can use to render your UI.
1919
+ *
1920
+ * @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;
1921
+ *
1922
+ * @example
1923
+ * const { data, loading, error } = useGetSatisfactionMetricsQuery({
1924
+ * variables: {
1925
+ * filter: // value for 'filter'
1926
+ * },
1927
+ * });
1928
+ */
1929
+ export declare function useGetSatisfactionMetricsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables, "empty" | "complete" | "streaming", Types.GetSatisfactionMetricsQueryVariables>;
1930
+ export declare function useGetSatisfactionMetricsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables, "empty" | "complete" | "streaming">;
1931
+ export declare function useGetSatisfactionMetricsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>;
1932
+ export declare function useGetSatisfactionMetricsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSatisfactionMetricsQuery | undefined, Types.GetSatisfactionMetricsQueryVariables>;
1933
+ export type GetSatisfactionMetricsQueryHookResult = ReturnType<typeof useGetSatisfactionMetricsQuery>;
1934
+ export type GetSatisfactionMetricsLazyQueryHookResult = ReturnType<typeof useGetSatisfactionMetricsLazyQuery>;
1935
+ export type GetSatisfactionMetricsSuspenseQueryHookResult = ReturnType<typeof useGetSatisfactionMetricsSuspenseQuery>;
1936
+ export type GetSatisfactionMetricsQueryResult = Apollo.QueryResult<Types.GetSatisfactionMetricsQuery, Types.GetSatisfactionMetricsQueryVariables>;
1937
+ export declare const GetAgentProfilesDocument: Apollo.DocumentNode;
1938
+ /**
1939
+ * __useGetAgentProfilesQuery__
1940
+ *
1941
+ * To run a query within a React component, call `useGetAgentProfilesQuery` and pass it any options that fit your needs.
1942
+ * When your component renders, `useGetAgentProfilesQuery` returns an object from Apollo Client that contains loading, error, and data properties
1943
+ * you can use to render your UI.
1944
+ *
1945
+ * @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;
1946
+ *
1947
+ * @example
1948
+ * const { data, loading, error } = useGetAgentProfilesQuery({
1949
+ * variables: {
1950
+ * filter: // value for 'filter'
1951
+ * limit: // value for 'limit'
1952
+ * offset: // value for 'offset'
1953
+ * },
1954
+ * });
1955
+ */
1956
+ export declare function useGetAgentProfilesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables, "empty" | "complete" | "streaming", Types.GetAgentProfilesQueryVariables>;
1957
+ export declare function useGetAgentProfilesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables, "empty" | "complete" | "streaming">;
1958
+ export declare function useGetAgentProfilesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>;
1959
+ export declare function useGetAgentProfilesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetAgentProfilesQuery | undefined, Types.GetAgentProfilesQueryVariables>;
1960
+ export type GetAgentProfilesQueryHookResult = ReturnType<typeof useGetAgentProfilesQuery>;
1961
+ export type GetAgentProfilesLazyQueryHookResult = ReturnType<typeof useGetAgentProfilesLazyQuery>;
1962
+ export type GetAgentProfilesSuspenseQueryHookResult = ReturnType<typeof useGetAgentProfilesSuspenseQuery>;
1963
+ export type GetAgentProfilesQueryResult = Apollo.QueryResult<Types.GetAgentProfilesQuery, Types.GetAgentProfilesQueryVariables>;
1964
+ export declare const GetArticleDocument: Apollo.DocumentNode;
1965
+ /**
1966
+ * __useGetArticleQuery__
1967
+ *
1968
+ * To run a query within a React component, call `useGetArticleQuery` and pass it any options that fit your needs.
1969
+ * When your component renders, `useGetArticleQuery` returns an object from Apollo Client that contains loading, error, and data properties
1970
+ * you can use to render your UI.
1971
+ *
1972
+ * @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;
1973
+ *
1974
+ * @example
1975
+ * const { data, loading, error } = useGetArticleQuery({
1976
+ * variables: {
1977
+ * id: // value for 'id'
1978
+ * },
1979
+ * });
1980
+ */
1981
+ export declare function useGetArticleQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables> & ({
1982
+ variables: Types.GetArticleQueryVariables;
1983
+ skip?: boolean;
1984
+ } | {
1985
+ skip: boolean;
1986
+ })): ApolloReactHooks.useQuery.Result<Types.GetArticleQuery, Types.GetArticleQueryVariables, "empty" | "complete" | "streaming", Types.GetArticleQueryVariables>;
1987
+ export declare function useGetArticleLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetArticleQuery, Types.GetArticleQueryVariables, "empty" | "complete" | "streaming">;
1988
+ export declare function useGetArticleSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticleQuery, Types.GetArticleQueryVariables>;
1989
+ export declare function useGetArticleSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticleQuery, Types.GetArticleQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticleQuery | undefined, Types.GetArticleQueryVariables>;
1990
+ export type GetArticleQueryHookResult = ReturnType<typeof useGetArticleQuery>;
1991
+ export type GetArticleLazyQueryHookResult = ReturnType<typeof useGetArticleLazyQuery>;
1992
+ export type GetArticleSuspenseQueryHookResult = ReturnType<typeof useGetArticleSuspenseQuery>;
1993
+ export type GetArticleQueryResult = Apollo.QueryResult<Types.GetArticleQuery, Types.GetArticleQueryVariables>;
1994
+ export declare const GetArticlesDocument: Apollo.DocumentNode;
1995
+ /**
1996
+ * __useGetArticlesQuery__
1997
+ *
1998
+ * To run a query within a React component, call `useGetArticlesQuery` and pass it any options that fit your needs.
1999
+ * When your component renders, `useGetArticlesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2000
+ * you can use to render your UI.
2001
+ *
2002
+ * @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;
2003
+ *
2004
+ * @example
2005
+ * const { data, loading, error } = useGetArticlesQuery({
2006
+ * variables: {
2007
+ * filter: // value for 'filter'
2008
+ * limit: // value for 'limit'
2009
+ * offset: // value for 'offset'
2010
+ * },
2011
+ * });
2012
+ */
2013
+ export declare function useGetArticlesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetArticlesQuery, Types.GetArticlesQueryVariables, "empty" | "complete" | "streaming", Types.GetArticlesQueryVariables>;
2014
+ export declare function useGetArticlesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetArticlesQuery, Types.GetArticlesQueryVariables, "empty" | "complete" | "streaming">;
2015
+ export declare function useGetArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>;
2016
+ export declare function useGetArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetArticlesQuery | undefined, Types.GetArticlesQueryVariables>;
2017
+ export type GetArticlesQueryHookResult = ReturnType<typeof useGetArticlesQuery>;
2018
+ export type GetArticlesLazyQueryHookResult = ReturnType<typeof useGetArticlesLazyQuery>;
2019
+ export type GetArticlesSuspenseQueryHookResult = ReturnType<typeof useGetArticlesSuspenseQuery>;
2020
+ export type GetArticlesQueryResult = Apollo.QueryResult<Types.GetArticlesQuery, Types.GetArticlesQueryVariables>;
2021
+ export declare const GetCannedResponsesDocument: Apollo.DocumentNode;
2022
+ /**
2023
+ * __useGetCannedResponsesQuery__
2024
+ *
2025
+ * To run a query within a React component, call `useGetCannedResponsesQuery` and pass it any options that fit your needs.
2026
+ * When your component renders, `useGetCannedResponsesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2027
+ * you can use to render your UI.
2028
+ *
2029
+ * @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;
2030
+ *
2031
+ * @example
2032
+ * const { data, loading, error } = useGetCannedResponsesQuery({
2033
+ * variables: {
2034
+ * filter: // value for 'filter'
2035
+ * limit: // value for 'limit'
2036
+ * offset: // value for 'offset'
2037
+ * },
2038
+ * });
2039
+ */
2040
+ export declare function useGetCannedResponsesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables, "empty" | "complete" | "streaming", Types.GetCannedResponsesQueryVariables>;
2041
+ export declare function useGetCannedResponsesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables, "empty" | "complete" | "streaming">;
2042
+ export declare function useGetCannedResponsesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>;
2043
+ export declare function useGetCannedResponsesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetCannedResponsesQuery | undefined, Types.GetCannedResponsesQueryVariables>;
2044
+ export type GetCannedResponsesQueryHookResult = ReturnType<typeof useGetCannedResponsesQuery>;
2045
+ export type GetCannedResponsesLazyQueryHookResult = ReturnType<typeof useGetCannedResponsesLazyQuery>;
2046
+ export type GetCannedResponsesSuspenseQueryHookResult = ReturnType<typeof useGetCannedResponsesSuspenseQuery>;
2047
+ export type GetCannedResponsesQueryResult = Apollo.QueryResult<Types.GetCannedResponsesQuery, Types.GetCannedResponsesQueryVariables>;
2048
+ export declare const GetContactInquiriesDocument: Apollo.DocumentNode;
2049
+ /**
2050
+ * __useGetContactInquiriesQuery__
2051
+ *
2052
+ * To run a query within a React component, call `useGetContactInquiriesQuery` and pass it any options that fit your needs.
2053
+ * When your component renders, `useGetContactInquiriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2054
+ * you can use to render your UI.
2055
+ *
2056
+ * @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;
2057
+ *
2058
+ * @example
2059
+ * const { data, loading, error } = useGetContactInquiriesQuery({
2060
+ * variables: {
2061
+ * filter: // value for 'filter'
2062
+ * limit: // value for 'limit'
2063
+ * offset: // value for 'offset'
2064
+ * },
2065
+ * });
2066
+ */
2067
+ export declare function useGetContactInquiriesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables, "empty" | "complete" | "streaming", Types.GetContactInquiriesQueryVariables>;
2068
+ export declare function useGetContactInquiriesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables, "empty" | "complete" | "streaming">;
2069
+ export declare function useGetContactInquiriesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>;
2070
+ export declare function useGetContactInquiriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiriesQuery | undefined, Types.GetContactInquiriesQueryVariables>;
2071
+ export type GetContactInquiriesQueryHookResult = ReturnType<typeof useGetContactInquiriesQuery>;
2072
+ export type GetContactInquiriesLazyQueryHookResult = ReturnType<typeof useGetContactInquiriesLazyQuery>;
2073
+ export type GetContactInquiriesSuspenseQueryHookResult = ReturnType<typeof useGetContactInquiriesSuspenseQuery>;
2074
+ export type GetContactInquiriesQueryResult = Apollo.QueryResult<Types.GetContactInquiriesQuery, Types.GetContactInquiriesQueryVariables>;
2075
+ export declare const GetContactInquiryDocument: Apollo.DocumentNode;
2076
+ /**
2077
+ * __useGetContactInquiryQuery__
2078
+ *
2079
+ * To run a query within a React component, call `useGetContactInquiryQuery` and pass it any options that fit your needs.
2080
+ * When your component renders, `useGetContactInquiryQuery` returns an object from Apollo Client that contains loading, error, and data properties
2081
+ * you can use to render your UI.
2082
+ *
2083
+ * @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;
2084
+ *
2085
+ * @example
2086
+ * const { data, loading, error } = useGetContactInquiryQuery({
2087
+ * variables: {
2088
+ * id: // value for 'id'
2089
+ * },
2090
+ * });
2091
+ */
2092
+ export declare function useGetContactInquiryQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables> & ({
2093
+ variables: Types.GetContactInquiryQueryVariables;
2094
+ skip?: boolean;
2095
+ } | {
2096
+ skip: boolean;
2097
+ })): ApolloReactHooks.useQuery.Result<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables, "empty" | "complete" | "streaming", Types.GetContactInquiryQueryVariables>;
2098
+ export declare function useGetContactInquiryLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables, "empty" | "complete" | "streaming">;
2099
+ export declare function useGetContactInquirySuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>;
2100
+ export declare function useGetContactInquirySuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetContactInquiryQuery | undefined, Types.GetContactInquiryQueryVariables>;
2101
+ export type GetContactInquiryQueryHookResult = ReturnType<typeof useGetContactInquiryQuery>;
2102
+ export type GetContactInquiryLazyQueryHookResult = ReturnType<typeof useGetContactInquiryLazyQuery>;
2103
+ export type GetContactInquirySuspenseQueryHookResult = ReturnType<typeof useGetContactInquirySuspenseQuery>;
2104
+ export type GetContactInquiryQueryResult = Apollo.QueryResult<Types.GetContactInquiryQuery, Types.GetContactInquiryQueryVariables>;
2105
+ export declare const GetJobApplicationDocument: Apollo.DocumentNode;
2106
+ /**
2107
+ * __useGetJobApplicationQuery__
2108
+ *
2109
+ * To run a query within a React component, call `useGetJobApplicationQuery` and pass it any options that fit your needs.
2110
+ * When your component renders, `useGetJobApplicationQuery` returns an object from Apollo Client that contains loading, error, and data properties
2111
+ * you can use to render your UI.
2112
+ *
2113
+ * @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;
2114
+ *
2115
+ * @example
2116
+ * const { data, loading, error } = useGetJobApplicationQuery({
2117
+ * variables: {
2118
+ * id: // value for 'id'
2119
+ * },
2120
+ * });
2121
+ */
2122
+ export declare function useGetJobApplicationQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables> & ({
2123
+ variables: Types.GetJobApplicationQueryVariables;
2124
+ skip?: boolean;
2125
+ } | {
2126
+ skip: boolean;
2127
+ })): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationQueryVariables>;
2128
+ export declare function useGetJobApplicationLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables, "empty" | "complete" | "streaming">;
2129
+ export declare function useGetJobApplicationSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>;
2130
+ export declare function useGetJobApplicationSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationQuery | undefined, Types.GetJobApplicationQueryVariables>;
2131
+ export type GetJobApplicationQueryHookResult = ReturnType<typeof useGetJobApplicationQuery>;
2132
+ export type GetJobApplicationLazyQueryHookResult = ReturnType<typeof useGetJobApplicationLazyQuery>;
2133
+ export type GetJobApplicationSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationSuspenseQuery>;
2134
+ export type GetJobApplicationQueryResult = Apollo.QueryResult<Types.GetJobApplicationQuery, Types.GetJobApplicationQueryVariables>;
2135
+ export declare const GetJobApplicationResumeUrlDocument: Apollo.DocumentNode;
2136
+ /**
2137
+ * __useGetJobApplicationResumeUrlQuery__
2138
+ *
2139
+ * To run a query within a React component, call `useGetJobApplicationResumeUrlQuery` and pass it any options that fit your needs.
2140
+ * When your component renders, `useGetJobApplicationResumeUrlQuery` returns an object from Apollo Client that contains loading, error, and data properties
2141
+ * you can use to render your UI.
2142
+ *
2143
+ * @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;
2144
+ *
2145
+ * @example
2146
+ * const { data, loading, error } = useGetJobApplicationResumeUrlQuery({
2147
+ * variables: {
2148
+ * id: // value for 'id'
2149
+ * },
2150
+ * });
2151
+ */
2152
+ export declare function useGetJobApplicationResumeUrlQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables> & ({
2153
+ variables: Types.GetJobApplicationResumeUrlQueryVariables;
2154
+ skip?: boolean;
2155
+ } | {
2156
+ skip: boolean;
2157
+ })): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationResumeUrlQueryVariables>;
2158
+ export declare function useGetJobApplicationResumeUrlLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables, "empty" | "complete" | "streaming">;
2159
+ export declare function useGetJobApplicationResumeUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>;
2160
+ export declare function useGetJobApplicationResumeUrlSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationResumeUrlQuery | undefined, Types.GetJobApplicationResumeUrlQueryVariables>;
2161
+ export type GetJobApplicationResumeUrlQueryHookResult = ReturnType<typeof useGetJobApplicationResumeUrlQuery>;
2162
+ export type GetJobApplicationResumeUrlLazyQueryHookResult = ReturnType<typeof useGetJobApplicationResumeUrlLazyQuery>;
2163
+ export type GetJobApplicationResumeUrlSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationResumeUrlSuspenseQuery>;
2164
+ export type GetJobApplicationResumeUrlQueryResult = Apollo.QueryResult<Types.GetJobApplicationResumeUrlQuery, Types.GetJobApplicationResumeUrlQueryVariables>;
2165
+ export declare const GetJobApplicationsDocument: Apollo.DocumentNode;
2166
+ /**
2167
+ * __useGetJobApplicationsQuery__
2168
+ *
2169
+ * To run a query within a React component, call `useGetJobApplicationsQuery` and pass it any options that fit your needs.
2170
+ * When your component renders, `useGetJobApplicationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
2171
+ * you can use to render your UI.
2172
+ *
2173
+ * @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;
2174
+ *
2175
+ * @example
2176
+ * const { data, loading, error } = useGetJobApplicationsQuery({
2177
+ * variables: {
2178
+ * filter: // value for 'filter'
2179
+ * limit: // value for 'limit'
2180
+ * offset: // value for 'offset'
2181
+ * },
2182
+ * });
2183
+ */
2184
+ export declare function useGetJobApplicationsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables, "empty" | "complete" | "streaming", Types.GetJobApplicationsQueryVariables>;
2185
+ export declare function useGetJobApplicationsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables, "empty" | "complete" | "streaming">;
2186
+ export declare function useGetJobApplicationsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>;
2187
+ export declare function useGetJobApplicationsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetJobApplicationsQuery | undefined, Types.GetJobApplicationsQueryVariables>;
2188
+ export type GetJobApplicationsQueryHookResult = ReturnType<typeof useGetJobApplicationsQuery>;
2189
+ export type GetJobApplicationsLazyQueryHookResult = ReturnType<typeof useGetJobApplicationsLazyQuery>;
2190
+ export type GetJobApplicationsSuspenseQueryHookResult = ReturnType<typeof useGetJobApplicationsSuspenseQuery>;
2191
+ export type GetJobApplicationsQueryResult = Apollo.QueryResult<Types.GetJobApplicationsQuery, Types.GetJobApplicationsQueryVariables>;
2192
+ export declare const GetMyTicketsDocument: Apollo.DocumentNode;
2193
+ /**
2194
+ * __useGetMyTicketsQuery__
2195
+ *
2196
+ * To run a query within a React component, call `useGetMyTicketsQuery` and pass it any options that fit your needs.
2197
+ * When your component renders, `useGetMyTicketsQuery` returns an object from Apollo Client that contains loading, error, and data properties
2198
+ * you can use to render your UI.
2199
+ *
2200
+ * @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;
2201
+ *
2202
+ * @example
2203
+ * const { data, loading, error } = useGetMyTicketsQuery({
2204
+ * variables: {
2205
+ * filter: // value for 'filter'
2206
+ * limit: // value for 'limit'
2207
+ * offset: // value for 'offset'
2208
+ * },
2209
+ * });
2210
+ */
2211
+ export declare function useGetMyTicketsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables, "empty" | "complete" | "streaming", Types.GetMyTicketsQueryVariables>;
2212
+ export declare function useGetMyTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables, "empty" | "complete" | "streaming">;
2213
+ export declare function useGetMyTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>;
2214
+ export declare function useGetMyTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetMyTicketsQuery | undefined, Types.GetMyTicketsQueryVariables>;
2215
+ export type GetMyTicketsQueryHookResult = ReturnType<typeof useGetMyTicketsQuery>;
2216
+ export type GetMyTicketsLazyQueryHookResult = ReturnType<typeof useGetMyTicketsLazyQuery>;
2217
+ export type GetMyTicketsSuspenseQueryHookResult = ReturnType<typeof useGetMyTicketsSuspenseQuery>;
2218
+ export type GetMyTicketsQueryResult = Apollo.QueryResult<Types.GetMyTicketsQuery, Types.GetMyTicketsQueryVariables>;
2219
+ export declare const GetPopularArticlesDocument: Apollo.DocumentNode;
2220
+ /**
2221
+ * __useGetPopularArticlesQuery__
2222
+ *
2223
+ * To run a query within a React component, call `useGetPopularArticlesQuery` and pass it any options that fit your needs.
2224
+ * When your component renders, `useGetPopularArticlesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2225
+ * you can use to render your UI.
2226
+ *
2227
+ * @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;
2228
+ *
2229
+ * @example
2230
+ * const { data, loading, error } = useGetPopularArticlesQuery({
2231
+ * variables: {
2232
+ * limit: // value for 'limit'
2233
+ * },
2234
+ * });
2235
+ */
2236
+ export declare function useGetPopularArticlesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables, "empty" | "complete" | "streaming", Types.GetPopularArticlesQueryVariables>;
2237
+ export declare function useGetPopularArticlesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables, "empty" | "complete" | "streaming">;
2238
+ export declare function useGetPopularArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>;
2239
+ export declare function useGetPopularArticlesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetPopularArticlesQuery | undefined, Types.GetPopularArticlesQueryVariables>;
2240
+ export type GetPopularArticlesQueryHookResult = ReturnType<typeof useGetPopularArticlesQuery>;
2241
+ export type GetPopularArticlesLazyQueryHookResult = ReturnType<typeof useGetPopularArticlesLazyQuery>;
2242
+ export type GetPopularArticlesSuspenseQueryHookResult = ReturnType<typeof useGetPopularArticlesSuspenseQuery>;
2243
+ export type GetPopularArticlesQueryResult = Apollo.QueryResult<Types.GetPopularArticlesQuery, Types.GetPopularArticlesQueryVariables>;
2244
+ export declare const GetSlaPoliciesDocument: Apollo.DocumentNode;
2245
+ /**
2246
+ * __useGetSlaPoliciesQuery__
2247
+ *
2248
+ * To run a query within a React component, call `useGetSlaPoliciesQuery` and pass it any options that fit your needs.
2249
+ * When your component renders, `useGetSlaPoliciesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2250
+ * you can use to render your UI.
2251
+ *
2252
+ * @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;
2253
+ *
2254
+ * @example
2255
+ * const { data, loading, error } = useGetSlaPoliciesQuery({
2256
+ * variables: {
2257
+ * filter: // value for 'filter'
2258
+ * limit: // value for 'limit'
2259
+ * offset: // value for 'offset'
2260
+ * },
2261
+ * });
2262
+ */
2263
+ export declare function useGetSlaPoliciesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables, "empty" | "complete" | "streaming", Types.GetSlaPoliciesQueryVariables>;
2264
+ export declare function useGetSlaPoliciesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables, "empty" | "complete" | "streaming">;
2265
+ export declare function useGetSlaPoliciesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>;
2266
+ export declare function useGetSlaPoliciesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSlaPoliciesQuery | undefined, Types.GetSlaPoliciesQueryVariables>;
2267
+ export type GetSlaPoliciesQueryHookResult = ReturnType<typeof useGetSlaPoliciesQuery>;
2268
+ export type GetSlaPoliciesLazyQueryHookResult = ReturnType<typeof useGetSlaPoliciesLazyQuery>;
2269
+ export type GetSlaPoliciesSuspenseQueryHookResult = ReturnType<typeof useGetSlaPoliciesSuspenseQuery>;
2270
+ export type GetSlaPoliciesQueryResult = Apollo.QueryResult<Types.GetSlaPoliciesQuery, Types.GetSlaPoliciesQueryVariables>;
2271
+ export declare const GetSupportAnalyticsDocument: Apollo.DocumentNode;
2272
+ /**
2273
+ * __useGetSupportAnalyticsQuery__
2274
+ *
2275
+ * To run a query within a React component, call `useGetSupportAnalyticsQuery` and pass it any options that fit your needs.
2276
+ * When your component renders, `useGetSupportAnalyticsQuery` returns an object from Apollo Client that contains loading, error, and data properties
2277
+ * you can use to render your UI.
2278
+ *
2279
+ * @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;
2280
+ *
2281
+ * @example
2282
+ * const { data, loading, error } = useGetSupportAnalyticsQuery({
2283
+ * variables: {
2284
+ * filter: // value for 'filter'
2285
+ * },
2286
+ * });
2287
+ */
2288
+ export declare function useGetSupportAnalyticsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables, "empty" | "complete" | "streaming", Types.GetSupportAnalyticsQueryVariables>;
2289
+ export declare function useGetSupportAnalyticsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables, "empty" | "complete" | "streaming">;
2290
+ export declare function useGetSupportAnalyticsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>;
2291
+ export declare function useGetSupportAnalyticsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetSupportAnalyticsQuery | undefined, Types.GetSupportAnalyticsQueryVariables>;
2292
+ export type GetSupportAnalyticsQueryHookResult = ReturnType<typeof useGetSupportAnalyticsQuery>;
2293
+ export type GetSupportAnalyticsLazyQueryHookResult = ReturnType<typeof useGetSupportAnalyticsLazyQuery>;
2294
+ export type GetSupportAnalyticsSuspenseQueryHookResult = ReturnType<typeof useGetSupportAnalyticsSuspenseQuery>;
2295
+ export type GetSupportAnalyticsQueryResult = Apollo.QueryResult<Types.GetSupportAnalyticsQuery, Types.GetSupportAnalyticsQueryVariables>;
2296
+ export declare const GetTicketCategoriesDocument: Apollo.DocumentNode;
2297
+ /**
2298
+ * __useGetTicketCategoriesQuery__
2299
+ *
2300
+ * To run a query within a React component, call `useGetTicketCategoriesQuery` and pass it any options that fit your needs.
2301
+ * When your component renders, `useGetTicketCategoriesQuery` returns an object from Apollo Client that contains loading, error, and data properties
2302
+ * you can use to render your UI.
2303
+ *
2304
+ * @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;
2305
+ *
2306
+ * @example
2307
+ * const { data, loading, error } = useGetTicketCategoriesQuery({
2308
+ * variables: {
2309
+ * filter: // value for 'filter'
2310
+ * limit: // value for 'limit'
2311
+ * offset: // value for 'offset'
2312
+ * },
2313
+ * });
2314
+ */
2315
+ export declare function useGetTicketCategoriesQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketCategoriesQueryVariables>;
2316
+ export declare function useGetTicketCategoriesLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables, "empty" | "complete" | "streaming">;
2317
+ export declare function useGetTicketCategoriesSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>;
2318
+ export declare function useGetTicketCategoriesSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketCategoriesQuery | undefined, Types.GetTicketCategoriesQueryVariables>;
2319
+ export type GetTicketCategoriesQueryHookResult = ReturnType<typeof useGetTicketCategoriesQuery>;
2320
+ export type GetTicketCategoriesLazyQueryHookResult = ReturnType<typeof useGetTicketCategoriesLazyQuery>;
2321
+ export type GetTicketCategoriesSuspenseQueryHookResult = ReturnType<typeof useGetTicketCategoriesSuspenseQuery>;
2322
+ export type GetTicketCategoriesQueryResult = Apollo.QueryResult<Types.GetTicketCategoriesQuery, Types.GetTicketCategoriesQueryVariables>;
2323
+ export declare const GetTicketDetailDocument: Apollo.DocumentNode;
2324
+ /**
2325
+ * __useGetTicketDetailQuery__
2326
+ *
2327
+ * To run a query within a React component, call `useGetTicketDetailQuery` and pass it any options that fit your needs.
2328
+ * When your component renders, `useGetTicketDetailQuery` returns an object from Apollo Client that contains loading, error, and data properties
2329
+ * you can use to render your UI.
2330
+ *
2331
+ * @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;
2332
+ *
2333
+ * @example
2334
+ * const { data, loading, error } = useGetTicketDetailQuery({
2335
+ * variables: {
2336
+ * id: // value for 'id'
2337
+ * },
2338
+ * });
2339
+ */
2340
+ export declare function useGetTicketDetailQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables> & ({
2341
+ variables: Types.GetTicketDetailQueryVariables;
2342
+ skip?: boolean;
2343
+ } | {
2344
+ skip: boolean;
2345
+ })): ApolloReactHooks.useQuery.Result<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketDetailQueryVariables>;
2346
+ export declare function useGetTicketDetailLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables, "empty" | "complete" | "streaming">;
2347
+ export declare function useGetTicketDetailSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>;
2348
+ export declare function useGetTicketDetailSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketDetailQuery | undefined, Types.GetTicketDetailQueryVariables>;
2349
+ export type GetTicketDetailQueryHookResult = ReturnType<typeof useGetTicketDetailQuery>;
2350
+ export type GetTicketDetailLazyQueryHookResult = ReturnType<typeof useGetTicketDetailLazyQuery>;
2351
+ export type GetTicketDetailSuspenseQueryHookResult = ReturnType<typeof useGetTicketDetailSuspenseQuery>;
2352
+ export type GetTicketDetailQueryResult = Apollo.QueryResult<Types.GetTicketDetailQuery, Types.GetTicketDetailQueryVariables>;
2353
+ export declare const GetTicketTrendsDocument: Apollo.DocumentNode;
2354
+ /**
2355
+ * __useGetTicketTrendsQuery__
2356
+ *
2357
+ * To run a query within a React component, call `useGetTicketTrendsQuery` and pass it any options that fit your needs.
2358
+ * When your component renders, `useGetTicketTrendsQuery` returns an object from Apollo Client that contains loading, error, and data properties
2359
+ * you can use to render your UI.
2360
+ *
2361
+ * @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;
2362
+ *
2363
+ * @example
2364
+ * const { data, loading, error } = useGetTicketTrendsQuery({
2365
+ * variables: {
2366
+ * filter: // value for 'filter'
2367
+ * },
2368
+ * });
2369
+ */
2370
+ export declare function useGetTicketTrendsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketTrendsQueryVariables>;
2371
+ export declare function useGetTicketTrendsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables, "empty" | "complete" | "streaming">;
2372
+ export declare function useGetTicketTrendsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>;
2373
+ export declare function useGetTicketTrendsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketTrendsQuery | undefined, Types.GetTicketTrendsQueryVariables>;
2374
+ export type GetTicketTrendsQueryHookResult = ReturnType<typeof useGetTicketTrendsQuery>;
2375
+ export type GetTicketTrendsLazyQueryHookResult = ReturnType<typeof useGetTicketTrendsLazyQuery>;
2376
+ export type GetTicketTrendsSuspenseQueryHookResult = ReturnType<typeof useGetTicketTrendsSuspenseQuery>;
2377
+ export type GetTicketTrendsQueryResult = Apollo.QueryResult<Types.GetTicketTrendsQuery, Types.GetTicketTrendsQueryVariables>;
2378
+ export declare const GetTicketsDocument: Apollo.DocumentNode;
2379
+ /**
2380
+ * __useGetTicketsQuery__
2381
+ *
2382
+ * To run a query within a React component, call `useGetTicketsQuery` and pass it any options that fit your needs.
2383
+ * When your component renders, `useGetTicketsQuery` returns an object from Apollo Client that contains loading, error, and data properties
2384
+ * you can use to render your UI.
2385
+ *
2386
+ * @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;
2387
+ *
2388
+ * @example
2389
+ * const { data, loading, error } = useGetTicketsQuery({
2390
+ * variables: {
2391
+ * filter: // value for 'filter'
2392
+ * limit: // value for 'limit'
2393
+ * offset: // value for 'offset'
2394
+ * },
2395
+ * });
2396
+ */
2397
+ export declare function useGetTicketsQuery(baseOptions?: ApolloReactHooks.QueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.useQuery.Result<Types.GetTicketsQuery, Types.GetTicketsQueryVariables, "empty" | "complete" | "streaming", Types.GetTicketsQueryVariables>;
2398
+ export declare function useGetTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.GetTicketsQuery, Types.GetTicketsQueryVariables, "empty" | "complete" | "streaming">;
2399
+ export declare function useGetTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>;
2400
+ export declare function useGetTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.GetTicketsQuery | undefined, Types.GetTicketsQueryVariables>;
2401
+ export type GetTicketsQueryHookResult = ReturnType<typeof useGetTicketsQuery>;
2402
+ export type GetTicketsLazyQueryHookResult = ReturnType<typeof useGetTicketsLazyQuery>;
2403
+ export type GetTicketsSuspenseQueryHookResult = ReturnType<typeof useGetTicketsSuspenseQuery>;
2404
+ export type GetTicketsQueryResult = Apollo.QueryResult<Types.GetTicketsQuery, Types.GetTicketsQueryVariables>;
2405
+ export declare const SearchKnowledgeBaseDocument: Apollo.DocumentNode;
2406
+ /**
2407
+ * __useSearchKnowledgeBaseQuery__
2408
+ *
2409
+ * To run a query within a React component, call `useSearchKnowledgeBaseQuery` and pass it any options that fit your needs.
2410
+ * When your component renders, `useSearchKnowledgeBaseQuery` returns an object from Apollo Client that contains loading, error, and data properties
2411
+ * you can use to render your UI.
2412
+ *
2413
+ * @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;
2414
+ *
2415
+ * @example
2416
+ * const { data, loading, error } = useSearchKnowledgeBaseQuery({
2417
+ * variables: {
2418
+ * query: // value for 'query'
2419
+ * categoryId: // value for 'categoryId'
2420
+ * limit: // value for 'limit'
2421
+ * },
2422
+ * });
2423
+ */
2424
+ export declare function useSearchKnowledgeBaseQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables> & ({
2425
+ variables: Types.SearchKnowledgeBaseQueryVariables;
2426
+ skip?: boolean;
2427
+ } | {
2428
+ skip: boolean;
2429
+ })): ApolloReactHooks.useQuery.Result<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables, "empty" | "complete" | "streaming", Types.SearchKnowledgeBaseQueryVariables>;
2430
+ export declare function useSearchKnowledgeBaseLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables, "empty" | "complete" | "streaming">;
2431
+ export declare function useSearchKnowledgeBaseSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>;
2432
+ export declare function useSearchKnowledgeBaseSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchKnowledgeBaseQuery | undefined, Types.SearchKnowledgeBaseQueryVariables>;
2433
+ export type SearchKnowledgeBaseQueryHookResult = ReturnType<typeof useSearchKnowledgeBaseQuery>;
2434
+ export type SearchKnowledgeBaseLazyQueryHookResult = ReturnType<typeof useSearchKnowledgeBaseLazyQuery>;
2435
+ export type SearchKnowledgeBaseSuspenseQueryHookResult = ReturnType<typeof useSearchKnowledgeBaseSuspenseQuery>;
2436
+ export type SearchKnowledgeBaseQueryResult = Apollo.QueryResult<Types.SearchKnowledgeBaseQuery, Types.SearchKnowledgeBaseQueryVariables>;
2437
+ export declare const SearchTicketsDocument: Apollo.DocumentNode;
2438
+ /**
2439
+ * __useSearchTicketsQuery__
2440
+ *
2441
+ * To run a query within a React component, call `useSearchTicketsQuery` and pass it any options that fit your needs.
2442
+ * When your component renders, `useSearchTicketsQuery` returns an object from Apollo Client that contains loading, error, and data properties
2443
+ * you can use to render your UI.
2444
+ *
2445
+ * @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;
2446
+ *
2447
+ * @example
2448
+ * const { data, loading, error } = useSearchTicketsQuery({
2449
+ * variables: {
2450
+ * query: // value for 'query'
2451
+ * limit: // value for 'limit'
2452
+ * },
2453
+ * });
2454
+ */
2455
+ export declare function useSearchTicketsQuery(baseOptions: ApolloReactHooks.QueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables> & ({
2456
+ variables: Types.SearchTicketsQueryVariables;
2457
+ skip?: boolean;
2458
+ } | {
2459
+ skip: boolean;
2460
+ })): ApolloReactHooks.useQuery.Result<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables, "empty" | "complete" | "streaming", Types.SearchTicketsQueryVariables>;
2461
+ export declare function useSearchTicketsLazyQuery(baseOptions?: ApolloReactHooks.LazyQueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>): ApolloReactHooks.useLazyQuery.ResultTuple<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables, "empty" | "complete" | "streaming">;
2462
+ export declare function useSearchTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>;
2463
+ export declare function useSearchTicketsSuspenseQuery(baseOptions?: ApolloReactHooks.SkipToken | ApolloReactHooks.SuspenseQueryHookOptions<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>): ApolloReactHooks.UseSuspenseQueryResult<Types.SearchTicketsQuery | undefined, Types.SearchTicketsQueryVariables>;
2464
+ export type SearchTicketsQueryHookResult = ReturnType<typeof useSearchTicketsQuery>;
2465
+ export type SearchTicketsLazyQueryHookResult = ReturnType<typeof useSearchTicketsLazyQuery>;
2466
+ export type SearchTicketsSuspenseQueryHookResult = ReturnType<typeof useSearchTicketsSuspenseQuery>;
2467
+ export type SearchTicketsQueryResult = Apollo.QueryResult<Types.SearchTicketsQuery, Types.SearchTicketsQueryVariables>;
2468
+ export declare const SubscribeTicketMessageAddedDocument: Apollo.DocumentNode;
2469
+ /**
2470
+ * __useSubscribeTicketMessageAddedSubscription__
2471
+ *
2472
+ * To run a query within a React component, call `useSubscribeTicketMessageAddedSubscription` and pass it any options that fit your needs.
2473
+ * When your component renders, `useSubscribeTicketMessageAddedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
2474
+ * you can use to render your UI.
2475
+ *
2476
+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2477
+ *
2478
+ * @example
2479
+ * const { data, loading, error } = useSubscribeTicketMessageAddedSubscription({
2480
+ * variables: {
2481
+ * ticketId: // value for 'ticketId'
2482
+ * },
2483
+ * });
2484
+ */
2485
+ export declare function useSubscribeTicketMessageAddedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.SubscribeTicketMessageAddedSubscription, Types.SubscribeTicketMessageAddedSubscriptionVariables> & ({
2486
+ variables: Types.SubscribeTicketMessageAddedSubscriptionVariables;
2487
+ skip?: boolean;
2488
+ } | {
2489
+ skip: boolean;
2490
+ })): ApolloReactHooks.useSubscription.Result<Types.SubscribeTicketMessageAddedSubscription>;
2491
+ export type SubscribeTicketMessageAddedSubscriptionHookResult = ReturnType<typeof useSubscribeTicketMessageAddedSubscription>;
2492
+ export type SubscribeTicketMessageAddedSubscriptionResult = Apollo.SubscriptionResult<Types.SubscribeTicketMessageAddedSubscription>;
2493
+ export declare const SubscribeTicketUpdatedDocument: Apollo.DocumentNode;
2494
+ /**
2495
+ * __useSubscribeTicketUpdatedSubscription__
2496
+ *
2497
+ * To run a query within a React component, call `useSubscribeTicketUpdatedSubscription` and pass it any options that fit your needs.
2498
+ * When your component renders, `useSubscribeTicketUpdatedSubscription` returns an object from Apollo Client that contains loading, error, and data properties
2499
+ * you can use to render your UI.
2500
+ *
2501
+ * @param baseOptions options that will be passed into the subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
2502
+ *
2503
+ * @example
2504
+ * const { data, loading, error } = useSubscribeTicketUpdatedSubscription({
2505
+ * variables: {
2506
+ * ticketId: // value for 'ticketId'
2507
+ * },
2508
+ * });
2509
+ */
2510
+ export declare function useSubscribeTicketUpdatedSubscription(baseOptions: ApolloReactHooks.SubscriptionHookOptions<Types.SubscribeTicketUpdatedSubscription, Types.SubscribeTicketUpdatedSubscriptionVariables> & ({
2511
+ variables: Types.SubscribeTicketUpdatedSubscriptionVariables;
2512
+ skip?: boolean;
2513
+ } | {
2514
+ skip: boolean;
2515
+ })): ApolloReactHooks.useSubscription.Result<Types.SubscribeTicketUpdatedSubscription>;
2516
+ export type SubscribeTicketUpdatedSubscriptionHookResult = ReturnType<typeof useSubscribeTicketUpdatedSubscription>;
2517
+ export type SubscribeTicketUpdatedSubscriptionResult = Apollo.SubscriptionResult<Types.SubscribeTicketUpdatedSubscription>;