@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.
- package/dist/generated/global-operations.d.ts +2517 -0
- package/dist/generated/global-types.d.ts +22913 -0
- package/dist/generated/wspace-operations.d.ts +1 -0
- package/dist/generated/wspace-types.d.ts +57850 -0
- package/dist/index.d.ts +5 -0
- package/dist/support/SupportAdminRoot.d.ts +20 -0
- package/dist/support/SupportAdminRoutes.d.ts +13 -0
- package/dist/support/SupportUserRoot.d.ts +17 -0
- package/dist/support/SupportUserRoutes.d.ts +11 -0
- package/dist/support/components/NotificationToast.d.ts +17 -0
- package/dist/support/components/PageLayout.d.ts +71 -0
- package/dist/support/components/RouteHelpers.d.ts +9 -0
- package/dist/support/components/analytics/CategoryBreakdown.d.ts +9 -0
- package/dist/support/components/analytics/MetricCard.d.ts +10 -0
- package/dist/support/components/analytics/PriorityBreakdown.d.ts +9 -0
- package/dist/support/components/analytics/SLAReport.d.ts +23 -0
- package/dist/support/components/analytics/SatisfactionDistribution.d.ts +23 -0
- package/dist/support/components/analytics/TopAgents.d.ts +19 -0
- package/dist/support/components/analytics/TrendChart.d.ts +15 -0
- package/dist/support/components/kb/ArticleForm.d.ts +25 -0
- package/dist/support/components/settings/CannedResponsesSettings.d.ts +21 -0
- package/dist/support/components/settings/SLAPoliciesSettings.d.ts +18 -0
- package/dist/support/components/settings/TicketCategoriesSettings.d.ts +20 -0
- package/dist/support/components/tickets/AttachmentList.d.ts +7 -0
- package/dist/support/components/tickets/MarkdownContent.d.ts +7 -0
- package/dist/support/components/tickets/MessageComposer.d.ts +22 -0
- package/dist/support/components/tickets/MessageThread.d.ts +12 -0
- package/dist/support/components/tickets/TicketDetailHeader.d.ts +16 -0
- package/dist/support/components/tickets/TicketHeader.d.ts +9 -0
- package/dist/support/components/tickets/TicketSidebar.d.ts +7 -0
- package/dist/support/components/ui.d.ts +5 -0
- package/dist/support/components/ui.js +2 -2
- package/dist/support/constants.d.ts +20 -0
- package/dist/support/events/rybbit.d.ts +13 -0
- package/dist/support/hooks/index.d.ts +5 -0
- package/dist/support/hooks/useAnalyticsOperations.d.ts +51 -0
- package/dist/support/hooks/useAttachmentsFailedToast.d.ts +2 -0
- package/dist/support/hooks/useChatOperations.d.ts +27 -0
- package/dist/support/hooks/useKnowledgeBaseOperations.d.ts +55 -0
- package/dist/support/hooks/useNotification.d.ts +20 -0
- package/dist/support/hooks/useRegisterFooter.d.ts +6 -0
- package/dist/support/hooks/useSettingsOperations.d.ts +47 -0
- package/dist/support/hooks/useSupportAttachments.d.ts +10 -0
- package/dist/support/hooks/useTicketListOperations.d.ts +31 -0
- package/dist/support/hooks/useTicketOperations.d.ts +39 -0
- package/dist/support/index.d.ts +44 -0
- package/dist/support/pages/AnalyticsPage.d.ts +1 -0
- package/dist/support/pages/AnalyticsPage.js +144 -113
- package/dist/support/pages/AnalyticsPage.js.map +1 -1
- package/dist/support/pages/ArticleDetailAdminPage.d.ts +7 -0
- package/dist/support/pages/ArticleDetailAdminPage.js +150 -113
- package/dist/support/pages/ArticleDetailAdminPage.js.map +1 -1
- package/dist/support/pages/ArticleDetailUserPage.d.ts +7 -0
- package/dist/support/pages/ArticleDetailUserPage.js +90 -83
- package/dist/support/pages/ArticleDetailUserPage.js.map +1 -1
- package/dist/support/pages/ContactInquiriesPage.d.ts +1 -0
- package/dist/support/pages/ContactInquiriesPage.js +48 -44
- package/dist/support/pages/ContactInquiriesPage.js.map +1 -1
- package/dist/support/pages/ContactInquiryDetailPage.d.ts +1 -0
- package/dist/support/pages/ContactInquiryDetailPage.js +225 -205
- package/dist/support/pages/ContactInquiryDetailPage.js.map +1 -1
- package/dist/support/pages/CreateArticlePage.d.ts +1 -0
- package/dist/support/pages/CreateArticlePage.js +50 -46
- package/dist/support/pages/CreateArticlePage.js.map +1 -1
- package/dist/support/pages/CreateTicketPage.d.ts +1 -0
- package/dist/support/pages/CreateTicketPage.js +122 -116
- package/dist/support/pages/CreateTicketPage.js.map +1 -1
- package/dist/support/pages/EditArticlePage.d.ts +1 -0
- package/dist/support/pages/EditArticlePage.js +76 -80
- package/dist/support/pages/EditArticlePage.js.map +1 -1
- package/dist/support/pages/JobApplicationDetailPage.d.ts +1 -0
- package/dist/support/pages/JobApplicationDetailPage.js +292 -269
- package/dist/support/pages/JobApplicationDetailPage.js.map +1 -1
- package/dist/support/pages/JobApplicationsPage.d.ts +1 -0
- package/dist/support/pages/JobApplicationsPage.js +50 -46
- package/dist/support/pages/JobApplicationsPage.js.map +1 -1
- package/dist/support/pages/KnowledgeBaseAdminPage.d.ts +7 -0
- package/dist/support/pages/KnowledgeBaseAdminPage.js +84 -81
- package/dist/support/pages/KnowledgeBaseAdminPage.js.map +1 -1
- package/dist/support/pages/KnowledgeBaseUserPage.d.ts +8 -0
- package/dist/support/pages/KnowledgeBaseUserPage.js +76 -75
- package/dist/support/pages/KnowledgeBaseUserPage.js.map +1 -1
- package/dist/support/pages/SettingsPage.d.ts +1 -0
- package/dist/support/pages/SettingsPage.js +215 -182
- package/dist/support/pages/SettingsPage.js.map +1 -1
- package/dist/support/pages/TicketDetailAdminPage.d.ts +8 -0
- package/dist/support/pages/TicketDetailAdminPage.js +158 -128
- package/dist/support/pages/TicketDetailAdminPage.js.map +1 -1
- package/dist/support/pages/TicketDetailUserPage.d.ts +8 -0
- package/dist/support/pages/TicketDetailUserPage.js +174 -141
- package/dist/support/pages/TicketDetailUserPage.js.map +1 -1
- package/dist/support/pages/TicketListPage.d.ts +11 -0
- package/dist/support/pages/TicketListPage.js +171 -170
- package/dist/support/pages/TicketListPage.js.map +1 -1
- package/dist/support/providers/SupportProvider.d.ts +16 -0
- package/dist/support/store/supportStore.d.ts +66 -0
- package/dist/support/types/index.d.ts +160 -0
- package/dist/support/utils/attachments.d.ts +27 -0
- package/dist/support/utils/categoryColors.d.ts +10 -0
- package/dist/support/utils/cn.d.ts +6 -0
- package/dist/support/utils/context.d.ts +2 -0
- package/dist/support/utils/errors.d.ts +2 -0
- package/dist/support/utils/i18n.d.ts +4 -0
- package/dist/support/utils/index.d.ts +57 -0
- package/dist/support/utils/markdown.d.ts +2 -0
- package/dist/support/utils/supportFiles.d.ts +15 -0
- package/dist/support/utils/ticketFilters.d.ts +6 -0
- package/dist/support/utils/uiTokens.d.ts +7 -0
- package/dist/utils/nativeBridge.d.ts +2 -0
- 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>;
|