@bcrumbs.net/inbox 0.0.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/README.md +0 -0
- package/assets/ar/translation.json +495 -0
- package/assets/en/translation.json +497 -0
- package/index.esm.d.ts +1 -0
- package/index.esm.js +107964 -0
- package/package.json +23 -0
- package/src/graphql.autogenerated.d.ts +4168 -0
- package/src/lib/inbox.d.ts +7 -0
- package/src/lib/index.d.ts +2 -0
- package/src/lib/test.d.ts +3 -0
|
@@ -0,0 +1,4168 @@
|
|
|
1
|
+
import * as Apollo from '@apollo/client';
|
|
2
|
+
export type Maybe<T> = T | null;
|
|
3
|
+
export type InputMaybe<T> = Maybe<T>;
|
|
4
|
+
export type Exact<T extends {
|
|
5
|
+
[key: string]: unknown;
|
|
6
|
+
}> = {
|
|
7
|
+
[K in keyof T]: T[K];
|
|
8
|
+
};
|
|
9
|
+
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
|
|
10
|
+
[SubKey in K]?: Maybe<T[SubKey]>;
|
|
11
|
+
};
|
|
12
|
+
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
|
|
13
|
+
[SubKey in K]: Maybe<T[SubKey]>;
|
|
14
|
+
};
|
|
15
|
+
export type MakeEmpty<T extends {
|
|
16
|
+
[key: string]: unknown;
|
|
17
|
+
}, K extends keyof T> = {
|
|
18
|
+
[_ in K]?: never;
|
|
19
|
+
};
|
|
20
|
+
export type Incremental<T> = T | {
|
|
21
|
+
[P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
|
|
22
|
+
};
|
|
23
|
+
/** All built-in and custom scalars, mapped to their actual values */
|
|
24
|
+
export type Scalars = {
|
|
25
|
+
ID: {
|
|
26
|
+
input: string;
|
|
27
|
+
output: string;
|
|
28
|
+
};
|
|
29
|
+
String: {
|
|
30
|
+
input: string;
|
|
31
|
+
output: string;
|
|
32
|
+
};
|
|
33
|
+
Boolean: {
|
|
34
|
+
input: boolean;
|
|
35
|
+
output: boolean;
|
|
36
|
+
};
|
|
37
|
+
Int: {
|
|
38
|
+
input: number;
|
|
39
|
+
output: number;
|
|
40
|
+
};
|
|
41
|
+
Float: {
|
|
42
|
+
input: number;
|
|
43
|
+
output: number;
|
|
44
|
+
};
|
|
45
|
+
BigInt: {
|
|
46
|
+
input: any;
|
|
47
|
+
output: any;
|
|
48
|
+
};
|
|
49
|
+
CountryCode: {
|
|
50
|
+
input: any;
|
|
51
|
+
output: any;
|
|
52
|
+
};
|
|
53
|
+
Date: {
|
|
54
|
+
input: any;
|
|
55
|
+
output: any;
|
|
56
|
+
};
|
|
57
|
+
DateTime: {
|
|
58
|
+
input: any;
|
|
59
|
+
output: any;
|
|
60
|
+
};
|
|
61
|
+
EmailAddress: {
|
|
62
|
+
input: any;
|
|
63
|
+
output: any;
|
|
64
|
+
};
|
|
65
|
+
JSON: {
|
|
66
|
+
input: any;
|
|
67
|
+
output: any;
|
|
68
|
+
};
|
|
69
|
+
PhoneNumber: {
|
|
70
|
+
input: any;
|
|
71
|
+
output: any;
|
|
72
|
+
};
|
|
73
|
+
Timestamp: {
|
|
74
|
+
input: any;
|
|
75
|
+
output: any;
|
|
76
|
+
};
|
|
77
|
+
URL: {
|
|
78
|
+
input: any;
|
|
79
|
+
output: any;
|
|
80
|
+
};
|
|
81
|
+
};
|
|
82
|
+
export type Agent = {
|
|
83
|
+
__typename?: 'Agent';
|
|
84
|
+
createdAt: Scalars['DateTime']['output'];
|
|
85
|
+
email: Scalars['String']['output'];
|
|
86
|
+
id: Scalars['ID']['output'];
|
|
87
|
+
name: Scalars['String']['output'];
|
|
88
|
+
surname: Scalars['String']['output'];
|
|
89
|
+
userId: Scalars['String']['output'];
|
|
90
|
+
workspaceId: Scalars['Int']['output'];
|
|
91
|
+
};
|
|
92
|
+
export type AgentCreateInput = {
|
|
93
|
+
email: Scalars['String']['input'];
|
|
94
|
+
name: Scalars['String']['input'];
|
|
95
|
+
surname: Scalars['String']['input'];
|
|
96
|
+
userId: Scalars['String']['input'];
|
|
97
|
+
workspaceId: Scalars['Int']['input'];
|
|
98
|
+
};
|
|
99
|
+
export type AgentInput = {
|
|
100
|
+
id: Scalars['ID']['input'];
|
|
101
|
+
workspaceId: Scalars['Int']['input'];
|
|
102
|
+
};
|
|
103
|
+
export type AgentPatchInput = {
|
|
104
|
+
id: Scalars['ID']['input'];
|
|
105
|
+
name: Scalars['String']['input'];
|
|
106
|
+
surname: Scalars['String']['input'];
|
|
107
|
+
workspaceId: Scalars['Int']['input'];
|
|
108
|
+
};
|
|
109
|
+
export type AgentReport = {
|
|
110
|
+
__typename?: 'AgentReport';
|
|
111
|
+
agentId: Scalars['ID']['output'];
|
|
112
|
+
agentMessagesCount: Scalars['Int']['output'];
|
|
113
|
+
avgConversationTime: Scalars['Int']['output'];
|
|
114
|
+
avgFirstResponseTime: Scalars['Int']['output'];
|
|
115
|
+
clientMessageCount: Scalars['Int']['output'];
|
|
116
|
+
conversationCount: Scalars['Int']['output'];
|
|
117
|
+
createdAt: Scalars['DateTime']['output'];
|
|
118
|
+
id: Scalars['ID']['output'];
|
|
119
|
+
workspaceId: Scalars['Int']['output'];
|
|
120
|
+
};
|
|
121
|
+
export type AgentsInput = {
|
|
122
|
+
conversationId?: InputMaybe<Scalars['String']['input']>;
|
|
123
|
+
email?: InputMaybe<Scalars['String']['input']>;
|
|
124
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
125
|
+
surname?: InputMaybe<Scalars['String']['input']>;
|
|
126
|
+
workspaceId: Scalars['Int']['input'];
|
|
127
|
+
};
|
|
128
|
+
export type AgentsPayload = {
|
|
129
|
+
__typename?: 'AgentsPayload';
|
|
130
|
+
nodes?: Maybe<Array<Agent>>;
|
|
131
|
+
pageInfo?: Maybe<PageInfo>;
|
|
132
|
+
};
|
|
133
|
+
export type AgentsReportInput = {
|
|
134
|
+
agentId?: InputMaybe<Scalars['ID']['input']>;
|
|
135
|
+
endDate: Scalars['DateTime']['input'];
|
|
136
|
+
startDate: Scalars['DateTime']['input'];
|
|
137
|
+
workspaceId: Scalars['Int']['input'];
|
|
138
|
+
};
|
|
139
|
+
export type AgentsReportPayload = {
|
|
140
|
+
__typename?: 'AgentsReportPayload';
|
|
141
|
+
nodes?: Maybe<Array<AgentReport>>;
|
|
142
|
+
};
|
|
143
|
+
export type Ai = {
|
|
144
|
+
__typename?: 'AI';
|
|
145
|
+
createdAt: Scalars['DateTime']['output'];
|
|
146
|
+
deletedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
147
|
+
id: Scalars['ID']['output'];
|
|
148
|
+
name: Scalars['String']['output'];
|
|
149
|
+
type: AiType;
|
|
150
|
+
workspaceId: Scalars['Int']['output'];
|
|
151
|
+
};
|
|
152
|
+
export type AiCreateInput = {
|
|
153
|
+
integrationProperties: Scalars['JSON']['input'];
|
|
154
|
+
name: Scalars['String']['input'];
|
|
155
|
+
type: AiType;
|
|
156
|
+
workspaceId: Scalars['Int']['input'];
|
|
157
|
+
};
|
|
158
|
+
export type AiDeleteInput = {
|
|
159
|
+
id: Scalars['ID']['input'];
|
|
160
|
+
workspaceId: Scalars['Int']['input'];
|
|
161
|
+
};
|
|
162
|
+
export type AiInput = {
|
|
163
|
+
id: Scalars['ID']['input'];
|
|
164
|
+
workspaceId: Scalars['Int']['input'];
|
|
165
|
+
};
|
|
166
|
+
export type AiPatchInput = {
|
|
167
|
+
id: Scalars['ID']['input'];
|
|
168
|
+
integrationProperties?: InputMaybe<Scalars['JSON']['input']>;
|
|
169
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
170
|
+
workspaceId: Scalars['Int']['input'];
|
|
171
|
+
};
|
|
172
|
+
export type AIsInput = {
|
|
173
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
174
|
+
type?: InputMaybe<AiType>;
|
|
175
|
+
workspaceId: Scalars['Int']['input'];
|
|
176
|
+
};
|
|
177
|
+
export type AIsPayload = {
|
|
178
|
+
__typename?: 'AIsPayload';
|
|
179
|
+
nodes?: Maybe<Array<Ai>>;
|
|
180
|
+
};
|
|
181
|
+
export declare const AiType: {
|
|
182
|
+
readonly OPENAI: "openai";
|
|
183
|
+
readonly PINECONE: "pinecone";
|
|
184
|
+
};
|
|
185
|
+
export type AiType = typeof AiType[keyof typeof AiType];
|
|
186
|
+
export type ApiKey = {
|
|
187
|
+
__typename?: 'ApiKey';
|
|
188
|
+
createdAt: Scalars['DateTime']['output'];
|
|
189
|
+
id: Scalars['ID']['output'];
|
|
190
|
+
key: Scalars['String']['output'];
|
|
191
|
+
label: Scalars['String']['output'];
|
|
192
|
+
workspaceId: Scalars['Int']['output'];
|
|
193
|
+
};
|
|
194
|
+
export type ApiKeyDeleteInput = {
|
|
195
|
+
id: Scalars['ID']['input'];
|
|
196
|
+
workspaceId: Scalars['Int']['input'];
|
|
197
|
+
};
|
|
198
|
+
export type ApiKeyGenInput = {
|
|
199
|
+
label: Scalars['String']['input'];
|
|
200
|
+
workspaceId: Scalars['Int']['input'];
|
|
201
|
+
};
|
|
202
|
+
export type ApiKeysInput = {
|
|
203
|
+
label?: InputMaybe<Scalars['String']['input']>;
|
|
204
|
+
workspaceId: Scalars['Int']['input'];
|
|
205
|
+
};
|
|
206
|
+
export type ApiKeysPayload = {
|
|
207
|
+
__typename?: 'ApiKeysPayload';
|
|
208
|
+
nodes?: Maybe<Array<ApiKey>>;
|
|
209
|
+
pageInfo?: Maybe<PageInfo>;
|
|
210
|
+
};
|
|
211
|
+
export type Broadcast = {
|
|
212
|
+
__typename?: 'Broadcast';
|
|
213
|
+
clientStageId?: Maybe<Scalars['String']['output']>;
|
|
214
|
+
clientTags?: Maybe<Array<Scalars['String']['output']>>;
|
|
215
|
+
completedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
216
|
+
createdAt: Scalars['DateTime']['output'];
|
|
217
|
+
error?: Maybe<Scalars['String']['output']>;
|
|
218
|
+
failedCount?: Maybe<Scalars['Int']['output']>;
|
|
219
|
+
id: Scalars['ID']['output'];
|
|
220
|
+
integrationId: Scalars['ID']['output'];
|
|
221
|
+
name: Scalars['String']['output'];
|
|
222
|
+
scheduledAt?: Maybe<Scalars['DateTime']['output']>;
|
|
223
|
+
startedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
224
|
+
state: BroadcastState;
|
|
225
|
+
templateLang?: Maybe<Scalars['String']['output']>;
|
|
226
|
+
templateName: Scalars['String']['output'];
|
|
227
|
+
totalCount?: Maybe<Scalars['Int']['output']>;
|
|
228
|
+
workspaceId: Scalars['Int']['output'];
|
|
229
|
+
};
|
|
230
|
+
export type BroadcastCreateInput = {
|
|
231
|
+
clientStageId?: InputMaybe<Scalars['String']['input']>;
|
|
232
|
+
clientTags?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
233
|
+
integrationId: Scalars['ID']['input'];
|
|
234
|
+
name: Scalars['String']['input'];
|
|
235
|
+
scheduledAt?: InputMaybe<Scalars['DateTime']['input']>;
|
|
236
|
+
templateLang?: InputMaybe<Scalars['String']['input']>;
|
|
237
|
+
templateName: Scalars['String']['input'];
|
|
238
|
+
workspaceId: Scalars['Int']['input'];
|
|
239
|
+
};
|
|
240
|
+
export type BroadcastDeleteInput = {
|
|
241
|
+
id: Scalars['ID']['input'];
|
|
242
|
+
workspaceId: Scalars['Int']['input'];
|
|
243
|
+
};
|
|
244
|
+
export type BroadcastInput = {
|
|
245
|
+
id: Scalars['ID']['input'];
|
|
246
|
+
workspaceId: Scalars['Int']['input'];
|
|
247
|
+
};
|
|
248
|
+
export type BroadcastLaunchInput = {
|
|
249
|
+
id: Scalars['ID']['input'];
|
|
250
|
+
workspaceId: Scalars['Int']['input'];
|
|
251
|
+
};
|
|
252
|
+
export type BroadcastPatchInput = {
|
|
253
|
+
clientStageId?: InputMaybe<Scalars['String']['input']>;
|
|
254
|
+
clientTags?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
255
|
+
id: Scalars['ID']['input'];
|
|
256
|
+
integrationId?: InputMaybe<Scalars['ID']['input']>;
|
|
257
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
258
|
+
scheduledAt?: InputMaybe<Scalars['DateTime']['input']>;
|
|
259
|
+
templateLang?: InputMaybe<Scalars['String']['input']>;
|
|
260
|
+
templateName: Scalars['String']['input'];
|
|
261
|
+
workspaceId: Scalars['Int']['input'];
|
|
262
|
+
};
|
|
263
|
+
export type BroadcastsInput = {
|
|
264
|
+
integrationId?: InputMaybe<Scalars['ID']['input']>;
|
|
265
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
266
|
+
state?: InputMaybe<BroadcastState>;
|
|
267
|
+
templateName?: InputMaybe<Scalars['String']['input']>;
|
|
268
|
+
workspaceId: Scalars['Int']['input'];
|
|
269
|
+
};
|
|
270
|
+
export type BroadcastsPayload = {
|
|
271
|
+
__typename?: 'BroadcastsPayload';
|
|
272
|
+
nodes?: Maybe<Array<Broadcast>>;
|
|
273
|
+
pageInfo?: Maybe<PageInfo>;
|
|
274
|
+
};
|
|
275
|
+
export declare const BroadcastState: {
|
|
276
|
+
readonly COMPLETED: "completed";
|
|
277
|
+
readonly DRAFT: "draft";
|
|
278
|
+
readonly FAILED: "failed";
|
|
279
|
+
readonly INPROGRESS: "inProgress";
|
|
280
|
+
readonly SCHEDULED: "scheduled";
|
|
281
|
+
};
|
|
282
|
+
export type BroadcastState = typeof BroadcastState[keyof typeof BroadcastState];
|
|
283
|
+
export type Client = {
|
|
284
|
+
__typename?: 'Client';
|
|
285
|
+
address?: Maybe<Scalars['String']['output']>;
|
|
286
|
+
city?: Maybe<Scalars['String']['output']>;
|
|
287
|
+
code?: Maybe<Scalars['String']['output']>;
|
|
288
|
+
country?: Maybe<Scalars['String']['output']>;
|
|
289
|
+
createdAt: Scalars['DateTime']['output'];
|
|
290
|
+
email?: Maybe<Scalars['String']['output']>;
|
|
291
|
+
externalClientId?: Maybe<Scalars['String']['output']>;
|
|
292
|
+
id: Scalars['ID']['output'];
|
|
293
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
294
|
+
phone?: Maybe<Scalars['String']['output']>;
|
|
295
|
+
stageId?: Maybe<Scalars['String']['output']>;
|
|
296
|
+
surname?: Maybe<Scalars['String']['output']>;
|
|
297
|
+
tags?: Maybe<Array<Scalars['String']['output']>>;
|
|
298
|
+
workspaceId: Scalars['Int']['output'];
|
|
299
|
+
};
|
|
300
|
+
export type ClientInput = {
|
|
301
|
+
id: Scalars['ID']['input'];
|
|
302
|
+
workspaceId: Scalars['Int']['input'];
|
|
303
|
+
};
|
|
304
|
+
export type ClientPatchInput = {
|
|
305
|
+
address?: InputMaybe<Scalars['String']['input']>;
|
|
306
|
+
city?: InputMaybe<Scalars['String']['input']>;
|
|
307
|
+
code?: InputMaybe<Scalars['String']['input']>;
|
|
308
|
+
country?: InputMaybe<Scalars['String']['input']>;
|
|
309
|
+
email?: InputMaybe<Scalars['String']['input']>;
|
|
310
|
+
id: Scalars['ID']['input'];
|
|
311
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
312
|
+
phone?: InputMaybe<Scalars['String']['input']>;
|
|
313
|
+
stage?: InputMaybe<Scalars['String']['input']>;
|
|
314
|
+
surname?: InputMaybe<Scalars['String']['input']>;
|
|
315
|
+
workspaceId: Scalars['Int']['input'];
|
|
316
|
+
};
|
|
317
|
+
export type ClientsInput = {
|
|
318
|
+
city?: InputMaybe<Scalars['String']['input']>;
|
|
319
|
+
code?: InputMaybe<Scalars['String']['input']>;
|
|
320
|
+
conversationId?: InputMaybe<Scalars['String']['input']>;
|
|
321
|
+
country?: InputMaybe<Scalars['String']['input']>;
|
|
322
|
+
email?: InputMaybe<Scalars['String']['input']>;
|
|
323
|
+
externalClientId?: InputMaybe<Scalars['String']['input']>;
|
|
324
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
325
|
+
phone?: InputMaybe<Scalars['String']['input']>;
|
|
326
|
+
stageId?: InputMaybe<Scalars['String']['input']>;
|
|
327
|
+
surname?: InputMaybe<Scalars['String']['input']>;
|
|
328
|
+
tags?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
329
|
+
workspaceId: Scalars['Int']['input'];
|
|
330
|
+
};
|
|
331
|
+
export type ClientsPayload = {
|
|
332
|
+
__typename?: 'ClientsPayload';
|
|
333
|
+
nodes?: Maybe<Array<Client>>;
|
|
334
|
+
pageInfo?: Maybe<PageInfo>;
|
|
335
|
+
};
|
|
336
|
+
export type ClientTagInput = {
|
|
337
|
+
clientId: Scalars['ID']['input'];
|
|
338
|
+
tag: Scalars['String']['input'];
|
|
339
|
+
workspaceId: Scalars['Int']['input'];
|
|
340
|
+
};
|
|
341
|
+
export type ConvAssignInput = {
|
|
342
|
+
agentId?: InputMaybe<Scalars['ID']['input']>;
|
|
343
|
+
convId: Scalars['ID']['input'];
|
|
344
|
+
integrationId: Scalars['ID']['input'];
|
|
345
|
+
workspaceId: Scalars['Int']['input'];
|
|
346
|
+
};
|
|
347
|
+
export type ConvAssignment = {
|
|
348
|
+
__typename?: 'ConvAssignment';
|
|
349
|
+
assignDate?: Maybe<Scalars['DateTime']['output']>;
|
|
350
|
+
assigneeId: Scalars['ID']['output'];
|
|
351
|
+
isAi?: Maybe<Scalars['Boolean']['output']>;
|
|
352
|
+
};
|
|
353
|
+
export type ConvEndInput = {
|
|
354
|
+
convId: Scalars['ID']['input'];
|
|
355
|
+
integrationId: Scalars['ID']['input'];
|
|
356
|
+
workspaceId: Scalars['Int']['input'];
|
|
357
|
+
};
|
|
358
|
+
export type Conversation = {
|
|
359
|
+
__typename?: 'Conversation';
|
|
360
|
+
aiAssigneed?: Maybe<Scalars['Boolean']['output']>;
|
|
361
|
+
aiId?: Maybe<Scalars['ID']['output']>;
|
|
362
|
+
assignee?: Maybe<Agent>;
|
|
363
|
+
assigneeId?: Maybe<Scalars['ID']['output']>;
|
|
364
|
+
assignees?: Maybe<Array<Maybe<ConvAssignment>>>;
|
|
365
|
+
client?: Maybe<ConversationClient>;
|
|
366
|
+
clientId: Scalars['ID']['output'];
|
|
367
|
+
createdAt: Scalars['DateTime']['output'];
|
|
368
|
+
ended: Scalars['Boolean']['output'];
|
|
369
|
+
endedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
370
|
+
externalConversationId?: Maybe<Scalars['String']['output']>;
|
|
371
|
+
id: Scalars['ID']['output'];
|
|
372
|
+
integrationId: Scalars['ID']['output'];
|
|
373
|
+
integrationType: IntegrationType;
|
|
374
|
+
messages?: Maybe<Array<Message>>;
|
|
375
|
+
orderNo?: Maybe<Scalars['String']['output']>;
|
|
376
|
+
stageId?: Maybe<Scalars['String']['output']>;
|
|
377
|
+
tags?: Maybe<Array<Scalars['String']['output']>>;
|
|
378
|
+
workspaceId: Scalars['Int']['output'];
|
|
379
|
+
};
|
|
380
|
+
export type ConversationClient = {
|
|
381
|
+
__typename?: 'ConversationClient';
|
|
382
|
+
code?: Maybe<Scalars['String']['output']>;
|
|
383
|
+
name?: Maybe<Scalars['String']['output']>;
|
|
384
|
+
surname?: Maybe<Scalars['String']['output']>;
|
|
385
|
+
};
|
|
386
|
+
export type ConversationReport = {
|
|
387
|
+
__typename?: 'ConversationReport';
|
|
388
|
+
agentMessagesCount: Scalars['Int']['output'];
|
|
389
|
+
avgConversationTime: Scalars['Int']['output'];
|
|
390
|
+
avgFirstResponseTime: Scalars['Int']['output'];
|
|
391
|
+
clientMessageCount: Scalars['Int']['output'];
|
|
392
|
+
conversationCount: Scalars['Int']['output'];
|
|
393
|
+
createdAt: Scalars['DateTime']['output'];
|
|
394
|
+
hour: Scalars['Int']['output'];
|
|
395
|
+
id: Scalars['ID']['output'];
|
|
396
|
+
integrationId: Scalars['ID']['output'];
|
|
397
|
+
workspaceId: Scalars['Int']['output'];
|
|
398
|
+
};
|
|
399
|
+
export type ConvPatchInput = {
|
|
400
|
+
convId: Scalars['ID']['input'];
|
|
401
|
+
integrationId: Scalars['ID']['input'];
|
|
402
|
+
orderNo?: InputMaybe<Scalars['String']['input']>;
|
|
403
|
+
stage?: InputMaybe<Scalars['String']['input']>;
|
|
404
|
+
workspaceId: Scalars['Int']['input'];
|
|
405
|
+
};
|
|
406
|
+
export type ConvsInput = {
|
|
407
|
+
assigneeId?: InputMaybe<Scalars['ID']['input']>;
|
|
408
|
+
clientId?: InputMaybe<Scalars['ID']['input']>;
|
|
409
|
+
ended?: InputMaybe<Scalars['Boolean']['input']>;
|
|
410
|
+
externalConversationId?: InputMaybe<Scalars['String']['input']>;
|
|
411
|
+
integrationId?: InputMaybe<Scalars['ID']['input']>;
|
|
412
|
+
stageId?: InputMaybe<Scalars['String']['input']>;
|
|
413
|
+
tags?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
414
|
+
workspaceId: Scalars['Int']['input'];
|
|
415
|
+
};
|
|
416
|
+
export type ConvsPayload = {
|
|
417
|
+
__typename?: 'ConvsPayload';
|
|
418
|
+
nodes?: Maybe<Array<Conversation>>;
|
|
419
|
+
pageInfo?: Maybe<PageInfo>;
|
|
420
|
+
};
|
|
421
|
+
export type ConvsReportInput = {
|
|
422
|
+
endDate: Scalars['DateTime']['input'];
|
|
423
|
+
integrationId?: InputMaybe<Scalars['ID']['input']>;
|
|
424
|
+
startDate: Scalars['DateTime']['input'];
|
|
425
|
+
workspaceId: Scalars['Int']['input'];
|
|
426
|
+
};
|
|
427
|
+
export type ConvsReportPayload = {
|
|
428
|
+
__typename?: 'ConvsReportPayload';
|
|
429
|
+
nodes?: Maybe<Array<ConversationReport>>;
|
|
430
|
+
};
|
|
431
|
+
export type ConvStartInput = {
|
|
432
|
+
clientId?: InputMaybe<Scalars['ID']['input']>;
|
|
433
|
+
integrationId: Scalars['ID']['input'];
|
|
434
|
+
phone?: InputMaybe<Scalars['String']['input']>;
|
|
435
|
+
templateLang?: InputMaybe<Scalars['String']['input']>;
|
|
436
|
+
templateName: Scalars['String']['input'];
|
|
437
|
+
workspaceId: Scalars['Int']['input'];
|
|
438
|
+
};
|
|
439
|
+
export type ConvTagInput = {
|
|
440
|
+
convId: Scalars['ID']['input'];
|
|
441
|
+
integrationId: Scalars['ID']['input'];
|
|
442
|
+
tag: Scalars['String']['input'];
|
|
443
|
+
workspaceId: Scalars['Int']['input'];
|
|
444
|
+
};
|
|
445
|
+
export declare const ErrorCode: {
|
|
446
|
+
readonly FILE_NOT_FOUND: "FILE_NOT_FOUND";
|
|
447
|
+
readonly FILE_UPLOAD_ERROR: "FILE_UPLOAD_ERROR";
|
|
448
|
+
readonly FORBIDDEN: "FORBIDDEN";
|
|
449
|
+
readonly RATE_LIMIT_ERROR: "RATE_LIMIT_ERROR";
|
|
450
|
+
readonly UNAUTHENTICATED: "UNAUTHENTICATED";
|
|
451
|
+
};
|
|
452
|
+
export type ErrorCode = typeof ErrorCode[keyof typeof ErrorCode];
|
|
453
|
+
export type HelloMessage = {
|
|
454
|
+
__typename?: 'HelloMessage';
|
|
455
|
+
message: Scalars['String']['output'];
|
|
456
|
+
};
|
|
457
|
+
export type IdUpdateDto = {
|
|
458
|
+
__typename?: 'IdUpdateDTO';
|
|
459
|
+
conversationId: Scalars['ID']['output'];
|
|
460
|
+
createdAt: Scalars['String']['output'];
|
|
461
|
+
debug?: Maybe<Scalars['Boolean']['output']>;
|
|
462
|
+
externalConversationId?: Maybe<Scalars['String']['output']>;
|
|
463
|
+
externalMessageId: Scalars['String']['output'];
|
|
464
|
+
integrationId: Scalars['ID']['output'];
|
|
465
|
+
integrationType: IntegrationType;
|
|
466
|
+
messageId: Scalars['ID']['output'];
|
|
467
|
+
spanId?: Maybe<Scalars['String']['output']>;
|
|
468
|
+
traceId?: Maybe<Scalars['String']['output']>;
|
|
469
|
+
workspaceId: Scalars['Int']['output'];
|
|
470
|
+
};
|
|
471
|
+
export type InputAccess = {
|
|
472
|
+
/** Specify the list of permissions that can access the resource. */
|
|
473
|
+
requiredPermissions?: InputMaybe<Array<Permission>>;
|
|
474
|
+
};
|
|
475
|
+
export type InputAssignUserOwner = {
|
|
476
|
+
email: Scalars['String']['input'];
|
|
477
|
+
userId: Scalars['String']['input'];
|
|
478
|
+
workspaceId: Scalars['Int']['input'];
|
|
479
|
+
};
|
|
480
|
+
export type InputAssignUserRole = {
|
|
481
|
+
email: Scalars['String']['input'];
|
|
482
|
+
role: Role;
|
|
483
|
+
userId: Scalars['String']['input'];
|
|
484
|
+
workspaceId: Scalars['Int']['input'];
|
|
485
|
+
};
|
|
486
|
+
export type InputInitWorkspace = {
|
|
487
|
+
workspaceId: Scalars['Int']['input'];
|
|
488
|
+
};
|
|
489
|
+
export type InputUploadSignature = {
|
|
490
|
+
type: MediaType;
|
|
491
|
+
};
|
|
492
|
+
export type InputUsersRoles = {
|
|
493
|
+
workspaceId: Scalars['Int']['input'];
|
|
494
|
+
};
|
|
495
|
+
export type Integration = {
|
|
496
|
+
__typename?: 'Integration';
|
|
497
|
+
createdAt: Scalars['DateTime']['output'];
|
|
498
|
+
deletedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
499
|
+
id: Scalars['ID']['output'];
|
|
500
|
+
name: Scalars['String']['output'];
|
|
501
|
+
patchedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
502
|
+
properties?: Maybe<Scalars['JSON']['output']>;
|
|
503
|
+
state: IntegrationState;
|
|
504
|
+
type: IntegrationType;
|
|
505
|
+
workspaceId: Scalars['Int']['output'];
|
|
506
|
+
};
|
|
507
|
+
export type IntegrationCreateInput = {
|
|
508
|
+
integrationProperties: Scalars['JSON']['input'];
|
|
509
|
+
name: Scalars['String']['input'];
|
|
510
|
+
type: IntegrationType;
|
|
511
|
+
workspaceId: Scalars['Int']['input'];
|
|
512
|
+
};
|
|
513
|
+
export type IntegrationDeleteInput = {
|
|
514
|
+
id: Scalars['ID']['input'];
|
|
515
|
+
workspaceId: Scalars['Int']['input'];
|
|
516
|
+
};
|
|
517
|
+
export type IntegrationInput = {
|
|
518
|
+
id: Scalars['ID']['input'];
|
|
519
|
+
workspaceId: Scalars['Int']['input'];
|
|
520
|
+
};
|
|
521
|
+
export type IntegrationPatchInput = {
|
|
522
|
+
id: Scalars['ID']['input'];
|
|
523
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
524
|
+
properties?: InputMaybe<Scalars['JSON']['input']>;
|
|
525
|
+
workspaceId: Scalars['Int']['input'];
|
|
526
|
+
};
|
|
527
|
+
export type IntegrationsInput = {
|
|
528
|
+
name?: InputMaybe<Scalars['String']['input']>;
|
|
529
|
+
state?: InputMaybe<IntegrationState>;
|
|
530
|
+
type?: InputMaybe<IntegrationType>;
|
|
531
|
+
workspaceId: Scalars['Int']['input'];
|
|
532
|
+
};
|
|
533
|
+
export type IntegrationsPayload = {
|
|
534
|
+
__typename?: 'IntegrationsPayload';
|
|
535
|
+
nodes?: Maybe<Array<Integration>>;
|
|
536
|
+
};
|
|
537
|
+
export declare const IntegrationState: {
|
|
538
|
+
readonly ACTIVE: "ACTIVE";
|
|
539
|
+
readonly DELETED: "DELETED";
|
|
540
|
+
readonly PENDING: "PENDING";
|
|
541
|
+
};
|
|
542
|
+
export type IntegrationState = typeof IntegrationState[keyof typeof IntegrationState];
|
|
543
|
+
export declare const IntegrationType: {
|
|
544
|
+
readonly BCWEBCHAT: "BCWEBCHAT";
|
|
545
|
+
readonly FACEBOOK: "FACEBOOK";
|
|
546
|
+
readonly INSTAGRAM: "INSTAGRAM";
|
|
547
|
+
readonly WHATSAPP: "WHATSAPP";
|
|
548
|
+
};
|
|
549
|
+
export type IntegrationType = typeof IntegrationType[keyof typeof IntegrationType];
|
|
550
|
+
export type IntegrationWithSecrets = {
|
|
551
|
+
__typename?: 'IntegrationWithSecrets';
|
|
552
|
+
createdAt: Scalars['DateTime']['output'];
|
|
553
|
+
deletedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
554
|
+
id: Scalars['ID']['output'];
|
|
555
|
+
integrationProperties: Scalars['JSON']['output'];
|
|
556
|
+
name: Scalars['String']['output'];
|
|
557
|
+
patchedAt?: Maybe<Scalars['DateTime']['output']>;
|
|
558
|
+
properties?: Maybe<Scalars['JSON']['output']>;
|
|
559
|
+
state: IntegrationState;
|
|
560
|
+
type: IntegrationType;
|
|
561
|
+
workspaceId: Scalars['Int']['output'];
|
|
562
|
+
};
|
|
563
|
+
export declare const MediaFormat: {
|
|
564
|
+
readonly GIF: "gif";
|
|
565
|
+
readonly JPG: "jpg";
|
|
566
|
+
readonly PDF: "pdf";
|
|
567
|
+
readonly PNG: "png";
|
|
568
|
+
readonly SVG: "svg";
|
|
569
|
+
};
|
|
570
|
+
export type MediaFormat = typeof MediaFormat[keyof typeof MediaFormat];
|
|
571
|
+
export declare const MediaType: {
|
|
572
|
+
readonly IMAGE: "IMAGE";
|
|
573
|
+
readonly PDF: "PDF";
|
|
574
|
+
};
|
|
575
|
+
export type MediaType = typeof MediaType[keyof typeof MediaType];
|
|
576
|
+
export type Message = {
|
|
577
|
+
__typename?: 'Message';
|
|
578
|
+
content: Scalars['String']['output'];
|
|
579
|
+
createdAt: Scalars['DateTime']['output'];
|
|
580
|
+
externalMessageId?: Maybe<Scalars['String']['output']>;
|
|
581
|
+
isAgent: Scalars['Boolean']['output'];
|
|
582
|
+
messageId: Scalars['ID']['output'];
|
|
583
|
+
status?: Maybe<MessageStatus>;
|
|
584
|
+
tags?: Maybe<Array<Scalars['String']['output']>>;
|
|
585
|
+
type: MessageType;
|
|
586
|
+
};
|
|
587
|
+
export type MessageDto = {
|
|
588
|
+
__typename?: 'MessageDTO';
|
|
589
|
+
clientId?: Maybe<Scalars['ID']['output']>;
|
|
590
|
+
content: Scalars['String']['output'];
|
|
591
|
+
conversationId?: Maybe<Scalars['ID']['output']>;
|
|
592
|
+
createdAt: Scalars['String']['output'];
|
|
593
|
+
debug?: Maybe<Scalars['Boolean']['output']>;
|
|
594
|
+
externalClientId: Scalars['String']['output'];
|
|
595
|
+
externalConversationId?: Maybe<Scalars['String']['output']>;
|
|
596
|
+
externalMessageId?: Maybe<Scalars['String']['output']>;
|
|
597
|
+
integrationId: Scalars['ID']['output'];
|
|
598
|
+
integrationType: IntegrationType;
|
|
599
|
+
isAgent?: Maybe<Scalars['Boolean']['output']>;
|
|
600
|
+
messageId?: Maybe<Scalars['ID']['output']>;
|
|
601
|
+
spanId?: Maybe<Scalars['String']['output']>;
|
|
602
|
+
tags?: Maybe<Array<Scalars['String']['output']>>;
|
|
603
|
+
traceId?: Maybe<Scalars['String']['output']>;
|
|
604
|
+
type: MessageType;
|
|
605
|
+
workspaceId: Scalars['Int']['output'];
|
|
606
|
+
};
|
|
607
|
+
export type MessageInput = {
|
|
608
|
+
content: Scalars['String']['input'];
|
|
609
|
+
convId: Scalars['ID']['input'];
|
|
610
|
+
integrationId: Scalars['ID']['input'];
|
|
611
|
+
type: MessageType;
|
|
612
|
+
workspaceId: Scalars['Int']['input'];
|
|
613
|
+
};
|
|
614
|
+
export type MessagesInput = {
|
|
615
|
+
assigneeId?: InputMaybe<Scalars['ID']['input']>;
|
|
616
|
+
clientId?: InputMaybe<Scalars['ID']['input']>;
|
|
617
|
+
endDate?: InputMaybe<Scalars['DateTime']['input']>;
|
|
618
|
+
startDate?: InputMaybe<Scalars['DateTime']['input']>;
|
|
619
|
+
tags?: InputMaybe<Array<Scalars['String']['input']>>;
|
|
620
|
+
type?: InputMaybe<MessageType>;
|
|
621
|
+
workspaceId: Scalars['Int']['input'];
|
|
622
|
+
};
|
|
623
|
+
export type MessagesPayload = {
|
|
624
|
+
__typename?: 'MessagesPayload';
|
|
625
|
+
nodes?: Maybe<Array<Message>>;
|
|
626
|
+
pageInfo?: Maybe<PageInfo>;
|
|
627
|
+
};
|
|
628
|
+
export declare const MessageStatus: {
|
|
629
|
+
readonly DELIVERED: "delivered";
|
|
630
|
+
readonly FAILED: "failed";
|
|
631
|
+
readonly PENDING: "pending";
|
|
632
|
+
readonly READ: "read";
|
|
633
|
+
readonly SENT: "sent";
|
|
634
|
+
};
|
|
635
|
+
export type MessageStatus = typeof MessageStatus[keyof typeof MessageStatus];
|
|
636
|
+
export type MessageTagInput = {
|
|
637
|
+
convId: Scalars['ID']['input'];
|
|
638
|
+
integrationId: Scalars['ID']['input'];
|
|
639
|
+
messageId: Scalars['ID']['input'];
|
|
640
|
+
tag: Scalars['String']['input'];
|
|
641
|
+
workspaceId: Scalars['Int']['input'];
|
|
642
|
+
};
|
|
643
|
+
export type MessageTemplate = {
|
|
644
|
+
__typename?: 'MessageTemplate';
|
|
645
|
+
category: Scalars['String']['output'];
|
|
646
|
+
id: Scalars['String']['output'];
|
|
647
|
+
language: Scalars['String']['output'];
|
|
648
|
+
library_template_name?: Maybe<Scalars['String']['output']>;
|
|
649
|
+
name: Scalars['String']['output'];
|
|
650
|
+
parameter_format?: Maybe<Scalars['String']['output']>;
|
|
651
|
+
status: TemplateState;
|
|
652
|
+
};
|
|
653
|
+
export type MessageTemplatesPayload = {
|
|
654
|
+
__typename?: 'MessageTemplatesPayload';
|
|
655
|
+
nodes?: Maybe<Array<MessageTemplate>>;
|
|
656
|
+
};
|
|
657
|
+
export declare const MessageType: {
|
|
658
|
+
readonly AUDIO: "audio";
|
|
659
|
+
readonly DOCUMENT: "document";
|
|
660
|
+
readonly IMAGE: "image";
|
|
661
|
+
readonly INTERACTIVE: "interactive";
|
|
662
|
+
readonly LOCATION: "location";
|
|
663
|
+
readonly NOTE: "note";
|
|
664
|
+
readonly TEMPLATE: "template";
|
|
665
|
+
readonly TEXT: "text";
|
|
666
|
+
readonly VIDEO: "video";
|
|
667
|
+
};
|
|
668
|
+
export type MessageType = typeof MessageType[keyof typeof MessageType];
|
|
669
|
+
export type Mutation = {
|
|
670
|
+
__typename?: 'Mutation';
|
|
671
|
+
addMessage: Message;
|
|
672
|
+
assignConv: Conversation;
|
|
673
|
+
assignOwner: UserRole;
|
|
674
|
+
assignUserRole: UserRole;
|
|
675
|
+
bulkPatchTags: Scalars['Boolean']['output'];
|
|
676
|
+
createAgent: Agent;
|
|
677
|
+
createAi: Ai;
|
|
678
|
+
createBroadcast: Broadcast;
|
|
679
|
+
createIntegration: Integration;
|
|
680
|
+
createTag: Tag;
|
|
681
|
+
createWebhook: Webhook;
|
|
682
|
+
deleteAgent: Agent;
|
|
683
|
+
deleteAi: Ai;
|
|
684
|
+
deleteApiKey: ApiKey;
|
|
685
|
+
deleteBroadcast: Broadcast;
|
|
686
|
+
deleteIntegration: Integration;
|
|
687
|
+
deleteTag: Tag;
|
|
688
|
+
deleteWebhook: Webhook;
|
|
689
|
+
endConv: Conversation;
|
|
690
|
+
genApiKey: ApiKey;
|
|
691
|
+
/** Required after the creation of a workspace to take ownership on it */
|
|
692
|
+
initWorkspace: UserRole;
|
|
693
|
+
launchBroadcast: Broadcast;
|
|
694
|
+
patchAgent: Agent;
|
|
695
|
+
patchAi: Ai;
|
|
696
|
+
patchBroadcast: Broadcast;
|
|
697
|
+
patchClient: Client;
|
|
698
|
+
patchConv: Conversation;
|
|
699
|
+
patchIntegration: Integration;
|
|
700
|
+
say?: Maybe<HelloMessage>;
|
|
701
|
+
startConv: Conversation;
|
|
702
|
+
tagClient: Client;
|
|
703
|
+
tagConv: Conversation;
|
|
704
|
+
tagMessage: Message;
|
|
705
|
+
untagClient: Client;
|
|
706
|
+
untagConv: Conversation;
|
|
707
|
+
untagMessage: Message;
|
|
708
|
+
};
|
|
709
|
+
export type MutationAddMessageArgs = {
|
|
710
|
+
input: MessageInput;
|
|
711
|
+
};
|
|
712
|
+
export type MutationAssignConvArgs = {
|
|
713
|
+
input: ConvAssignInput;
|
|
714
|
+
};
|
|
715
|
+
export type MutationAssignOwnerArgs = {
|
|
716
|
+
input: InputAssignUserOwner;
|
|
717
|
+
};
|
|
718
|
+
export type MutationAssignUserRoleArgs = {
|
|
719
|
+
input: InputAssignUserRole;
|
|
720
|
+
};
|
|
721
|
+
export type MutationBulkPatchTagsArgs = {
|
|
722
|
+
input: TagBulkPatchInput;
|
|
723
|
+
};
|
|
724
|
+
export type MutationCreateAgentArgs = {
|
|
725
|
+
input: AgentCreateInput;
|
|
726
|
+
};
|
|
727
|
+
export type MutationCreateAiArgs = {
|
|
728
|
+
input: AiCreateInput;
|
|
729
|
+
};
|
|
730
|
+
export type MutationCreateBroadcastArgs = {
|
|
731
|
+
input: BroadcastCreateInput;
|
|
732
|
+
};
|
|
733
|
+
export type MutationCreateIntegrationArgs = {
|
|
734
|
+
input: IntegrationCreateInput;
|
|
735
|
+
};
|
|
736
|
+
export type MutationCreateTagArgs = {
|
|
737
|
+
input: TagCreateInput;
|
|
738
|
+
};
|
|
739
|
+
export type MutationCreateWebhookArgs = {
|
|
740
|
+
input: WebhookCreateInput;
|
|
741
|
+
};
|
|
742
|
+
export type MutationDeleteAgentArgs = {
|
|
743
|
+
input: AgentInput;
|
|
744
|
+
};
|
|
745
|
+
export type MutationDeleteAiArgs = {
|
|
746
|
+
input: AiDeleteInput;
|
|
747
|
+
};
|
|
748
|
+
export type MutationDeleteApiKeyArgs = {
|
|
749
|
+
input: ApiKeyDeleteInput;
|
|
750
|
+
};
|
|
751
|
+
export type MutationDeleteBroadcastArgs = {
|
|
752
|
+
input: BroadcastDeleteInput;
|
|
753
|
+
};
|
|
754
|
+
export type MutationDeleteIntegrationArgs = {
|
|
755
|
+
input: IntegrationDeleteInput;
|
|
756
|
+
};
|
|
757
|
+
export type MutationDeleteTagArgs = {
|
|
758
|
+
input: TagDeleteInput;
|
|
759
|
+
};
|
|
760
|
+
export type MutationDeleteWebhookArgs = {
|
|
761
|
+
input: WebhookDeleteInput;
|
|
762
|
+
};
|
|
763
|
+
export type MutationEndConvArgs = {
|
|
764
|
+
input: ConvEndInput;
|
|
765
|
+
};
|
|
766
|
+
export type MutationGenApiKeyArgs = {
|
|
767
|
+
input: ApiKeyGenInput;
|
|
768
|
+
};
|
|
769
|
+
export type MutationInitWorkspaceArgs = {
|
|
770
|
+
input: InputInitWorkspace;
|
|
771
|
+
};
|
|
772
|
+
export type MutationLaunchBroadcastArgs = {
|
|
773
|
+
input: BroadcastLaunchInput;
|
|
774
|
+
};
|
|
775
|
+
export type MutationPatchAgentArgs = {
|
|
776
|
+
input: AgentPatchInput;
|
|
777
|
+
};
|
|
778
|
+
export type MutationPatchAiArgs = {
|
|
779
|
+
input: AiPatchInput;
|
|
780
|
+
};
|
|
781
|
+
export type MutationPatchBroadcastArgs = {
|
|
782
|
+
input: BroadcastPatchInput;
|
|
783
|
+
};
|
|
784
|
+
export type MutationPatchClientArgs = {
|
|
785
|
+
input: ClientPatchInput;
|
|
786
|
+
};
|
|
787
|
+
export type MutationPatchConvArgs = {
|
|
788
|
+
input: ConvPatchInput;
|
|
789
|
+
};
|
|
790
|
+
export type MutationPatchIntegrationArgs = {
|
|
791
|
+
input: IntegrationPatchInput;
|
|
792
|
+
};
|
|
793
|
+
export type MutationSayArgs = {
|
|
794
|
+
input: UserInput;
|
|
795
|
+
};
|
|
796
|
+
export type MutationStartConvArgs = {
|
|
797
|
+
input: ConvStartInput;
|
|
798
|
+
};
|
|
799
|
+
export type MutationTagClientArgs = {
|
|
800
|
+
input: ClientTagInput;
|
|
801
|
+
};
|
|
802
|
+
export type MutationTagConvArgs = {
|
|
803
|
+
input: ConvTagInput;
|
|
804
|
+
};
|
|
805
|
+
export type MutationTagMessageArgs = {
|
|
806
|
+
input: MessageTagInput;
|
|
807
|
+
};
|
|
808
|
+
export type MutationUntagClientArgs = {
|
|
809
|
+
input: ClientTagInput;
|
|
810
|
+
};
|
|
811
|
+
export type MutationUntagConvArgs = {
|
|
812
|
+
input: ConvTagInput;
|
|
813
|
+
};
|
|
814
|
+
export type MutationUntagMessageArgs = {
|
|
815
|
+
input: MessageTagInput;
|
|
816
|
+
};
|
|
817
|
+
export type PageInfo = {
|
|
818
|
+
__typename?: 'PageInfo';
|
|
819
|
+
count?: Maybe<Scalars['Int']['output']>;
|
|
820
|
+
endCursor?: Maybe<Scalars['Timestamp']['output']>;
|
|
821
|
+
hasNextPage: Scalars['Boolean']['output'];
|
|
822
|
+
};
|
|
823
|
+
export type PageInfoInput = {
|
|
824
|
+
count?: InputMaybe<Scalars['Boolean']['input']>;
|
|
825
|
+
cursor?: InputMaybe<Scalars['Timestamp']['input']>;
|
|
826
|
+
limit?: InputMaybe<Scalars['Int']['input']>;
|
|
827
|
+
query?: InputMaybe<Scalars['String']['input']>;
|
|
828
|
+
};
|
|
829
|
+
export declare const Permission: {
|
|
830
|
+
readonly MANAGE_CLIENTS: "MANAGE_CLIENTS";
|
|
831
|
+
readonly MANAGE_CONVS: "MANAGE_CONVS";
|
|
832
|
+
readonly MANAGE_OWNER: "MANAGE_OWNER";
|
|
833
|
+
readonly MANAGE_WORKSPACE: "MANAGE_WORKSPACE";
|
|
834
|
+
};
|
|
835
|
+
export type Permission = typeof Permission[keyof typeof Permission];
|
|
836
|
+
export type Query = {
|
|
837
|
+
__typename?: 'Query';
|
|
838
|
+
agent: Agent;
|
|
839
|
+
agents: AgentsPayload;
|
|
840
|
+
agentsReport: AgentsReportPayload;
|
|
841
|
+
ai: Ai;
|
|
842
|
+
ais: AIsPayload;
|
|
843
|
+
apiKeys: ApiKeysPayload;
|
|
844
|
+
broadcast: Broadcast;
|
|
845
|
+
broadcasts: BroadcastsPayload;
|
|
846
|
+
client: Client;
|
|
847
|
+
clients: ClientsPayload;
|
|
848
|
+
convs: ConvsPayload;
|
|
849
|
+
convsReport: ConvsReportPayload;
|
|
850
|
+
hello: HelloMessage;
|
|
851
|
+
integration: Integration;
|
|
852
|
+
integrations: IntegrationsPayload;
|
|
853
|
+
me: UserRole;
|
|
854
|
+
messages: MessagesPayload;
|
|
855
|
+
tags: TagsPayload;
|
|
856
|
+
uploadSignature: UploadSignatureResult;
|
|
857
|
+
usersRoles: UsersRolesPayload;
|
|
858
|
+
wabaMessageTemplates: MessageTemplatesPayload;
|
|
859
|
+
webhooks: WebhooksPayload;
|
|
860
|
+
};
|
|
861
|
+
export type QueryAgentArgs = {
|
|
862
|
+
input: AgentInput;
|
|
863
|
+
};
|
|
864
|
+
export type QueryAgentsArgs = {
|
|
865
|
+
input: AgentsInput;
|
|
866
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
867
|
+
};
|
|
868
|
+
export type QueryAgentsReportArgs = {
|
|
869
|
+
input: AgentsReportInput;
|
|
870
|
+
};
|
|
871
|
+
export type QueryAiArgs = {
|
|
872
|
+
input: AiInput;
|
|
873
|
+
};
|
|
874
|
+
export type QueryAisArgs = {
|
|
875
|
+
input: AIsInput;
|
|
876
|
+
};
|
|
877
|
+
export type QueryApiKeysArgs = {
|
|
878
|
+
input: ApiKeysInput;
|
|
879
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
880
|
+
};
|
|
881
|
+
export type QueryBroadcastArgs = {
|
|
882
|
+
input: BroadcastInput;
|
|
883
|
+
};
|
|
884
|
+
export type QueryBroadcastsArgs = {
|
|
885
|
+
input: BroadcastsInput;
|
|
886
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
887
|
+
};
|
|
888
|
+
export type QueryClientArgs = {
|
|
889
|
+
input: ClientInput;
|
|
890
|
+
};
|
|
891
|
+
export type QueryClientsArgs = {
|
|
892
|
+
input: ClientsInput;
|
|
893
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
894
|
+
};
|
|
895
|
+
export type QueryConvsArgs = {
|
|
896
|
+
input: ConvsInput;
|
|
897
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
898
|
+
};
|
|
899
|
+
export type QueryConvsReportArgs = {
|
|
900
|
+
input: ConvsReportInput;
|
|
901
|
+
};
|
|
902
|
+
export type QueryIntegrationArgs = {
|
|
903
|
+
input: IntegrationInput;
|
|
904
|
+
};
|
|
905
|
+
export type QueryIntegrationsArgs = {
|
|
906
|
+
input: IntegrationsInput;
|
|
907
|
+
};
|
|
908
|
+
export type QueryMeArgs = {
|
|
909
|
+
input: InputInitWorkspace;
|
|
910
|
+
};
|
|
911
|
+
export type QueryMessagesArgs = {
|
|
912
|
+
input: MessagesInput;
|
|
913
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
914
|
+
};
|
|
915
|
+
export type QueryTagsArgs = {
|
|
916
|
+
input: TagsInput;
|
|
917
|
+
};
|
|
918
|
+
export type QueryUploadSignatureArgs = {
|
|
919
|
+
input: InputUploadSignature;
|
|
920
|
+
};
|
|
921
|
+
export type QueryUsersRolesArgs = {
|
|
922
|
+
input: InputUsersRoles;
|
|
923
|
+
};
|
|
924
|
+
export type QueryWabaMessageTemplatesArgs = {
|
|
925
|
+
input: WabaMessageTemplatesInput;
|
|
926
|
+
};
|
|
927
|
+
export type QueryWebhooksArgs = {
|
|
928
|
+
input: WebhooksInput;
|
|
929
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
930
|
+
};
|
|
931
|
+
export declare const Role: {
|
|
932
|
+
readonly ADMIN: "ADMIN";
|
|
933
|
+
readonly AGENT: "AGENT";
|
|
934
|
+
readonly AGENT_PLUS: "AGENT_PLUS";
|
|
935
|
+
readonly MANAGER: "MANAGER";
|
|
936
|
+
readonly OWNER: "OWNER";
|
|
937
|
+
};
|
|
938
|
+
export type Role = typeof Role[keyof typeof Role];
|
|
939
|
+
export type StartByCountryCodeConfig = {
|
|
940
|
+
__typename?: 'StartByCountryCodeConfig';
|
|
941
|
+
assigneeId: Scalars['ID']['output'];
|
|
942
|
+
code: Scalars['String']['output'];
|
|
943
|
+
};
|
|
944
|
+
export declare const StartWithType: {
|
|
945
|
+
readonly AGENT: "AGENT";
|
|
946
|
+
readonly AGENT_BY_COUNTRY_CODE: "AGENT_BY_COUNTRY_CODE";
|
|
947
|
+
readonly AI: "AI";
|
|
948
|
+
readonly AI_BY_COUNTRY_CODE: "AI_BY_COUNTRY_CODE";
|
|
949
|
+
};
|
|
950
|
+
export type StartWithType = typeof StartWithType[keyof typeof StartWithType];
|
|
951
|
+
export type StatusUpdateDto = {
|
|
952
|
+
__typename?: 'StatusUpdateDTO';
|
|
953
|
+
createdAt: Scalars['String']['output'];
|
|
954
|
+
debug?: Maybe<Scalars['Boolean']['output']>;
|
|
955
|
+
externalConversationId?: Maybe<Scalars['String']['output']>;
|
|
956
|
+
externalMessageId: Scalars['String']['output'];
|
|
957
|
+
integrationId: Scalars['ID']['output'];
|
|
958
|
+
integrationType: IntegrationType;
|
|
959
|
+
spanId?: Maybe<Scalars['String']['output']>;
|
|
960
|
+
status: MessageStatus;
|
|
961
|
+
traceId?: Maybe<Scalars['String']['output']>;
|
|
962
|
+
workspaceId: Scalars['Int']['output'];
|
|
963
|
+
};
|
|
964
|
+
export type Tag = {
|
|
965
|
+
__typename?: 'Tag';
|
|
966
|
+
createdAt: Scalars['DateTime']['output'];
|
|
967
|
+
description?: Maybe<Scalars['String']['output']>;
|
|
968
|
+
id: Scalars['ID']['output'];
|
|
969
|
+
order?: Maybe<Scalars['Int']['output']>;
|
|
970
|
+
tag: Scalars['String']['output'];
|
|
971
|
+
type: TagType;
|
|
972
|
+
workspaceId: Scalars['Int']['output'];
|
|
973
|
+
};
|
|
974
|
+
export type TagBulkPatchInput = {
|
|
975
|
+
patches: Array<TagBulkPatchItemInput>;
|
|
976
|
+
workspaceId: Scalars['Int']['input'];
|
|
977
|
+
};
|
|
978
|
+
export type TagBulkPatchItemInput = {
|
|
979
|
+
description?: InputMaybe<Scalars['String']['input']>;
|
|
980
|
+
id: Scalars['ID']['input'];
|
|
981
|
+
order?: InputMaybe<Scalars['Int']['input']>;
|
|
982
|
+
};
|
|
983
|
+
export type TagCreateInput = {
|
|
984
|
+
description?: InputMaybe<Scalars['String']['input']>;
|
|
985
|
+
order?: InputMaybe<Scalars['Int']['input']>;
|
|
986
|
+
tag: Scalars['String']['input'];
|
|
987
|
+
type: TagType;
|
|
988
|
+
workspaceId: Scalars['Int']['input'];
|
|
989
|
+
};
|
|
990
|
+
export type TagDeleteInput = {
|
|
991
|
+
id: Scalars['ID']['input'];
|
|
992
|
+
workspaceId: Scalars['Int']['input'];
|
|
993
|
+
};
|
|
994
|
+
export type TagsInput = {
|
|
995
|
+
tag?: InputMaybe<Scalars['String']['input']>;
|
|
996
|
+
type?: InputMaybe<TagType>;
|
|
997
|
+
workspaceId: Scalars['Int']['input'];
|
|
998
|
+
};
|
|
999
|
+
export type TagsPayload = {
|
|
1000
|
+
__typename?: 'TagsPayload';
|
|
1001
|
+
nodes?: Maybe<Array<Tag>>;
|
|
1002
|
+
};
|
|
1003
|
+
export declare const TagType: {
|
|
1004
|
+
readonly CLIENT: "client";
|
|
1005
|
+
readonly CLIENTSTAGE: "clientStage";
|
|
1006
|
+
readonly COMMON: "common";
|
|
1007
|
+
readonly CONVERSATION: "conversation";
|
|
1008
|
+
readonly CONVSTAGE: "convStage";
|
|
1009
|
+
readonly MESSAGE: "message";
|
|
1010
|
+
};
|
|
1011
|
+
export type TagType = typeof TagType[keyof typeof TagType];
|
|
1012
|
+
export declare const TemplateState: {
|
|
1013
|
+
readonly APPROVED: "APPROVED";
|
|
1014
|
+
readonly DELETED: "DELETED";
|
|
1015
|
+
readonly PENDING: "PENDING";
|
|
1016
|
+
};
|
|
1017
|
+
export type TemplateState = typeof TemplateState[keyof typeof TemplateState];
|
|
1018
|
+
export type UploadSignatureResult = {
|
|
1019
|
+
__typename?: 'UploadSignatureResult';
|
|
1020
|
+
sas: Scalars['String']['output'];
|
|
1021
|
+
};
|
|
1022
|
+
export type UserInput = {
|
|
1023
|
+
message: Scalars['String']['input'];
|
|
1024
|
+
};
|
|
1025
|
+
export type UserRole = {
|
|
1026
|
+
__typename?: 'UserRole';
|
|
1027
|
+
createdAt: Scalars['DateTime']['output'];
|
|
1028
|
+
email: Scalars['String']['output'];
|
|
1029
|
+
id: Scalars['ID']['output'];
|
|
1030
|
+
role: Role;
|
|
1031
|
+
userId: Scalars['String']['output'];
|
|
1032
|
+
workspaceId: Scalars['Int']['output'];
|
|
1033
|
+
};
|
|
1034
|
+
export type UsersRolesPayload = {
|
|
1035
|
+
__typename?: 'UsersRolesPayload';
|
|
1036
|
+
nodes?: Maybe<Array<UserRole>>;
|
|
1037
|
+
};
|
|
1038
|
+
export type WabaMessageTemplatesInput = {
|
|
1039
|
+
integrationId: Scalars['ID']['input'];
|
|
1040
|
+
workspaceId: Scalars['Int']['input'];
|
|
1041
|
+
};
|
|
1042
|
+
export type Webhook = {
|
|
1043
|
+
__typename?: 'Webhook';
|
|
1044
|
+
createdAt: Scalars['DateTime']['output'];
|
|
1045
|
+
event: WebhookEvent;
|
|
1046
|
+
id: Scalars['ID']['output'];
|
|
1047
|
+
label: Scalars['String']['output'];
|
|
1048
|
+
url: Scalars['String']['output'];
|
|
1049
|
+
workspaceId: Scalars['Int']['output'];
|
|
1050
|
+
};
|
|
1051
|
+
export type WebhookCreateInput = {
|
|
1052
|
+
event: WebhookEvent;
|
|
1053
|
+
label: Scalars['String']['input'];
|
|
1054
|
+
url: Scalars['String']['input'];
|
|
1055
|
+
workspaceId: Scalars['Int']['input'];
|
|
1056
|
+
};
|
|
1057
|
+
export type WebhookDeleteInput = {
|
|
1058
|
+
id: Scalars['ID']['input'];
|
|
1059
|
+
workspaceId: Scalars['Int']['input'];
|
|
1060
|
+
};
|
|
1061
|
+
export declare const WebhookEvent: {
|
|
1062
|
+
readonly CLIENT_UPDATED: "CLIENT_UPDATED";
|
|
1063
|
+
readonly ENDING_CONV: "ENDING_CONV";
|
|
1064
|
+
readonly INCOMING_MESSAGE: "INCOMING_MESSAGE";
|
|
1065
|
+
readonly NEW_CLIENT: "NEW_CLIENT";
|
|
1066
|
+
readonly NEW_CONV: "NEW_CONV";
|
|
1067
|
+
readonly OUTGOING_MESSAGE: "OUTGOING_MESSAGE";
|
|
1068
|
+
};
|
|
1069
|
+
export type WebhookEvent = typeof WebhookEvent[keyof typeof WebhookEvent];
|
|
1070
|
+
export type WebhooksInput = {
|
|
1071
|
+
event?: InputMaybe<WebhookEvent>;
|
|
1072
|
+
label?: InputMaybe<Scalars['String']['input']>;
|
|
1073
|
+
workspaceId: Scalars['Int']['input'];
|
|
1074
|
+
};
|
|
1075
|
+
export type WebhooksPayload = {
|
|
1076
|
+
__typename?: 'WebhooksPayload';
|
|
1077
|
+
nodes?: Maybe<Array<Webhook>>;
|
|
1078
|
+
pageInfo?: Maybe<PageInfo>;
|
|
1079
|
+
};
|
|
1080
|
+
export type UserRoleFragment = {
|
|
1081
|
+
__typename?: 'UserRole';
|
|
1082
|
+
workspaceId: number;
|
|
1083
|
+
id: string;
|
|
1084
|
+
userId: string;
|
|
1085
|
+
email: string;
|
|
1086
|
+
role: Role;
|
|
1087
|
+
createdAt: any;
|
|
1088
|
+
};
|
|
1089
|
+
export type AssignOwnerMutationVariables = Exact<{
|
|
1090
|
+
input: InputAssignUserOwner;
|
|
1091
|
+
}>;
|
|
1092
|
+
export type AssignOwnerMutation = {
|
|
1093
|
+
__typename?: 'Mutation';
|
|
1094
|
+
assignOwner: {
|
|
1095
|
+
__typename?: 'UserRole';
|
|
1096
|
+
workspaceId: number;
|
|
1097
|
+
id: string;
|
|
1098
|
+
userId: string;
|
|
1099
|
+
email: string;
|
|
1100
|
+
role: Role;
|
|
1101
|
+
createdAt: any;
|
|
1102
|
+
};
|
|
1103
|
+
};
|
|
1104
|
+
export type AssignUserRoleMutationVariables = Exact<{
|
|
1105
|
+
input: InputAssignUserRole;
|
|
1106
|
+
}>;
|
|
1107
|
+
export type AssignUserRoleMutation = {
|
|
1108
|
+
__typename?: 'Mutation';
|
|
1109
|
+
assignUserRole: {
|
|
1110
|
+
__typename?: 'UserRole';
|
|
1111
|
+
workspaceId: number;
|
|
1112
|
+
id: string;
|
|
1113
|
+
userId: string;
|
|
1114
|
+
email: string;
|
|
1115
|
+
role: Role;
|
|
1116
|
+
createdAt: any;
|
|
1117
|
+
};
|
|
1118
|
+
};
|
|
1119
|
+
export type InitWorkspaceMutationVariables = Exact<{
|
|
1120
|
+
input: InputInitWorkspace;
|
|
1121
|
+
}>;
|
|
1122
|
+
export type InitWorkspaceMutation = {
|
|
1123
|
+
__typename?: 'Mutation';
|
|
1124
|
+
initWorkspace: {
|
|
1125
|
+
__typename?: 'UserRole';
|
|
1126
|
+
workspaceId: number;
|
|
1127
|
+
id: string;
|
|
1128
|
+
userId: string;
|
|
1129
|
+
email: string;
|
|
1130
|
+
role: Role;
|
|
1131
|
+
createdAt: any;
|
|
1132
|
+
};
|
|
1133
|
+
};
|
|
1134
|
+
export type MeQueryVariables = Exact<{
|
|
1135
|
+
input: InputInitWorkspace;
|
|
1136
|
+
}>;
|
|
1137
|
+
export type MeQuery = {
|
|
1138
|
+
__typename?: 'Query';
|
|
1139
|
+
me: {
|
|
1140
|
+
__typename?: 'UserRole';
|
|
1141
|
+
workspaceId: number;
|
|
1142
|
+
id: string;
|
|
1143
|
+
userId: string;
|
|
1144
|
+
email: string;
|
|
1145
|
+
role: Role;
|
|
1146
|
+
createdAt: any;
|
|
1147
|
+
};
|
|
1148
|
+
};
|
|
1149
|
+
export type UsersRolesQueryVariables = Exact<{
|
|
1150
|
+
input: InputUsersRoles;
|
|
1151
|
+
}>;
|
|
1152
|
+
export type UsersRolesQuery = {
|
|
1153
|
+
__typename?: 'Query';
|
|
1154
|
+
usersRoles: {
|
|
1155
|
+
__typename?: 'UsersRolesPayload';
|
|
1156
|
+
nodes?: Array<{
|
|
1157
|
+
__typename?: 'UserRole';
|
|
1158
|
+
workspaceId: number;
|
|
1159
|
+
id: string;
|
|
1160
|
+
userId: string;
|
|
1161
|
+
email: string;
|
|
1162
|
+
role: Role;
|
|
1163
|
+
createdAt: any;
|
|
1164
|
+
}> | null;
|
|
1165
|
+
};
|
|
1166
|
+
};
|
|
1167
|
+
export type AgentReportFragment = {
|
|
1168
|
+
__typename?: 'AgentReport';
|
|
1169
|
+
workspaceId: number;
|
|
1170
|
+
id: string;
|
|
1171
|
+
agentId: string;
|
|
1172
|
+
conversationCount: number;
|
|
1173
|
+
agentMessagesCount: number;
|
|
1174
|
+
clientMessageCount: number;
|
|
1175
|
+
avgFirstResponseTime: number;
|
|
1176
|
+
avgConversationTime: number;
|
|
1177
|
+
createdAt: any;
|
|
1178
|
+
};
|
|
1179
|
+
export type ConversationReportFragment = {
|
|
1180
|
+
__typename?: 'ConversationReport';
|
|
1181
|
+
workspaceId: number;
|
|
1182
|
+
id: string;
|
|
1183
|
+
integrationId: string;
|
|
1184
|
+
hour: number;
|
|
1185
|
+
conversationCount: number;
|
|
1186
|
+
agentMessagesCount: number;
|
|
1187
|
+
clientMessageCount: number;
|
|
1188
|
+
avgFirstResponseTime: number;
|
|
1189
|
+
avgConversationTime: number;
|
|
1190
|
+
createdAt: any;
|
|
1191
|
+
};
|
|
1192
|
+
export type AgentsReportQueryVariables = Exact<{
|
|
1193
|
+
input: AgentsReportInput;
|
|
1194
|
+
}>;
|
|
1195
|
+
export type AgentsReportQuery = {
|
|
1196
|
+
__typename?: 'Query';
|
|
1197
|
+
agentsReport: {
|
|
1198
|
+
__typename?: 'AgentsReportPayload';
|
|
1199
|
+
nodes?: Array<{
|
|
1200
|
+
__typename?: 'AgentReport';
|
|
1201
|
+
workspaceId: number;
|
|
1202
|
+
id: string;
|
|
1203
|
+
agentId: string;
|
|
1204
|
+
conversationCount: number;
|
|
1205
|
+
agentMessagesCount: number;
|
|
1206
|
+
clientMessageCount: number;
|
|
1207
|
+
avgFirstResponseTime: number;
|
|
1208
|
+
avgConversationTime: number;
|
|
1209
|
+
createdAt: any;
|
|
1210
|
+
}> | null;
|
|
1211
|
+
};
|
|
1212
|
+
};
|
|
1213
|
+
export type ConvsReportQueryVariables = Exact<{
|
|
1214
|
+
input: ConvsReportInput;
|
|
1215
|
+
}>;
|
|
1216
|
+
export type ConvsReportQuery = {
|
|
1217
|
+
__typename?: 'Query';
|
|
1218
|
+
convsReport: {
|
|
1219
|
+
__typename?: 'ConvsReportPayload';
|
|
1220
|
+
nodes?: Array<{
|
|
1221
|
+
__typename?: 'ConversationReport';
|
|
1222
|
+
workspaceId: number;
|
|
1223
|
+
id: string;
|
|
1224
|
+
integrationId: string;
|
|
1225
|
+
hour: number;
|
|
1226
|
+
conversationCount: number;
|
|
1227
|
+
agentMessagesCount: number;
|
|
1228
|
+
clientMessageCount: number;
|
|
1229
|
+
avgFirstResponseTime: number;
|
|
1230
|
+
avgConversationTime: number;
|
|
1231
|
+
createdAt: any;
|
|
1232
|
+
}> | null;
|
|
1233
|
+
};
|
|
1234
|
+
};
|
|
1235
|
+
export type PageInfoFragment = {
|
|
1236
|
+
__typename?: 'PageInfo';
|
|
1237
|
+
hasNextPage: boolean;
|
|
1238
|
+
endCursor?: any | null;
|
|
1239
|
+
count?: number | null;
|
|
1240
|
+
};
|
|
1241
|
+
export type AgentFragment = {
|
|
1242
|
+
__typename?: 'Agent';
|
|
1243
|
+
workspaceId: number;
|
|
1244
|
+
id: string;
|
|
1245
|
+
userId: string;
|
|
1246
|
+
name: string;
|
|
1247
|
+
surname: string;
|
|
1248
|
+
email: string;
|
|
1249
|
+
createdAt: any;
|
|
1250
|
+
};
|
|
1251
|
+
export type BroadcastFragment = {
|
|
1252
|
+
__typename?: 'Broadcast';
|
|
1253
|
+
workspaceId: number;
|
|
1254
|
+
id: string;
|
|
1255
|
+
name: string;
|
|
1256
|
+
integrationId: string;
|
|
1257
|
+
state: BroadcastState;
|
|
1258
|
+
clientTags?: Array<string> | null;
|
|
1259
|
+
clientStageId?: string | null;
|
|
1260
|
+
templateName: string;
|
|
1261
|
+
templateLang?: string | null;
|
|
1262
|
+
createdAt: any;
|
|
1263
|
+
scheduledAt?: any | null;
|
|
1264
|
+
startedAt?: any | null;
|
|
1265
|
+
completedAt?: any | null;
|
|
1266
|
+
totalCount?: number | null;
|
|
1267
|
+
failedCount?: number | null;
|
|
1268
|
+
error?: string | null;
|
|
1269
|
+
};
|
|
1270
|
+
export type ClientFragment = {
|
|
1271
|
+
__typename?: 'Client';
|
|
1272
|
+
workspaceId: number;
|
|
1273
|
+
id: string;
|
|
1274
|
+
email?: string | null;
|
|
1275
|
+
name?: string | null;
|
|
1276
|
+
surname?: string | null;
|
|
1277
|
+
phone?: string | null;
|
|
1278
|
+
address?: string | null;
|
|
1279
|
+
code?: string | null;
|
|
1280
|
+
city?: string | null;
|
|
1281
|
+
country?: string | null;
|
|
1282
|
+
externalClientId?: string | null;
|
|
1283
|
+
tags?: Array<string> | null;
|
|
1284
|
+
createdAt: any;
|
|
1285
|
+
stageId?: string | null;
|
|
1286
|
+
};
|
|
1287
|
+
export type ConversationFragment = {
|
|
1288
|
+
__typename?: 'Conversation';
|
|
1289
|
+
workspaceId: number;
|
|
1290
|
+
id: string;
|
|
1291
|
+
integrationId: string;
|
|
1292
|
+
integrationType: IntegrationType;
|
|
1293
|
+
clientId: string;
|
|
1294
|
+
ended: boolean;
|
|
1295
|
+
externalConversationId?: string | null;
|
|
1296
|
+
tags?: Array<string> | null;
|
|
1297
|
+
createdAt: any;
|
|
1298
|
+
endedAt?: any | null;
|
|
1299
|
+
stageId?: string | null;
|
|
1300
|
+
orderNo?: string | null;
|
|
1301
|
+
assigneeId?: string | null;
|
|
1302
|
+
aiId?: string | null;
|
|
1303
|
+
aiAssigneed?: boolean | null;
|
|
1304
|
+
messages?: Array<{
|
|
1305
|
+
__typename?: 'Message';
|
|
1306
|
+
messageId: string;
|
|
1307
|
+
content: string;
|
|
1308
|
+
type: MessageType;
|
|
1309
|
+
isAgent: boolean;
|
|
1310
|
+
status?: MessageStatus | null;
|
|
1311
|
+
externalMessageId?: string | null;
|
|
1312
|
+
tags?: Array<string> | null;
|
|
1313
|
+
createdAt: any;
|
|
1314
|
+
}> | null;
|
|
1315
|
+
client?: {
|
|
1316
|
+
__typename?: 'ConversationClient';
|
|
1317
|
+
name?: string | null;
|
|
1318
|
+
surname?: string | null;
|
|
1319
|
+
code?: string | null;
|
|
1320
|
+
} | null;
|
|
1321
|
+
assignees?: Array<{
|
|
1322
|
+
__typename?: 'ConvAssignment';
|
|
1323
|
+
assigneeId: string;
|
|
1324
|
+
assignDate?: any | null;
|
|
1325
|
+
isAi?: boolean | null;
|
|
1326
|
+
} | null> | null;
|
|
1327
|
+
};
|
|
1328
|
+
export type MessageFragment = {
|
|
1329
|
+
__typename?: 'Message';
|
|
1330
|
+
messageId: string;
|
|
1331
|
+
content: string;
|
|
1332
|
+
type: MessageType;
|
|
1333
|
+
isAgent: boolean;
|
|
1334
|
+
status?: MessageStatus | null;
|
|
1335
|
+
externalMessageId?: string | null;
|
|
1336
|
+
tags?: Array<string> | null;
|
|
1337
|
+
createdAt: any;
|
|
1338
|
+
};
|
|
1339
|
+
export type TagFragment = {
|
|
1340
|
+
__typename?: 'Tag';
|
|
1341
|
+
id: string;
|
|
1342
|
+
tag: string;
|
|
1343
|
+
type: TagType;
|
|
1344
|
+
createdAt: any;
|
|
1345
|
+
};
|
|
1346
|
+
export type MessageTemplateFragment = {
|
|
1347
|
+
__typename?: 'MessageTemplate';
|
|
1348
|
+
id: string;
|
|
1349
|
+
name: string;
|
|
1350
|
+
language: string;
|
|
1351
|
+
status: TemplateState;
|
|
1352
|
+
category: string;
|
|
1353
|
+
library_template_name?: string | null;
|
|
1354
|
+
parameter_format?: string | null;
|
|
1355
|
+
};
|
|
1356
|
+
export type AddMessageMutationVariables = Exact<{
|
|
1357
|
+
input: MessageInput;
|
|
1358
|
+
}>;
|
|
1359
|
+
export type AddMessageMutation = {
|
|
1360
|
+
__typename?: 'Mutation';
|
|
1361
|
+
addMessage: {
|
|
1362
|
+
__typename?: 'Message';
|
|
1363
|
+
messageId: string;
|
|
1364
|
+
content: string;
|
|
1365
|
+
type: MessageType;
|
|
1366
|
+
isAgent: boolean;
|
|
1367
|
+
status?: MessageStatus | null;
|
|
1368
|
+
externalMessageId?: string | null;
|
|
1369
|
+
tags?: Array<string> | null;
|
|
1370
|
+
createdAt: any;
|
|
1371
|
+
};
|
|
1372
|
+
};
|
|
1373
|
+
export type AgentQueryVariables = Exact<{
|
|
1374
|
+
input: AgentInput;
|
|
1375
|
+
}>;
|
|
1376
|
+
export type AgentQuery = {
|
|
1377
|
+
__typename?: 'Query';
|
|
1378
|
+
agent: {
|
|
1379
|
+
__typename?: 'Agent';
|
|
1380
|
+
workspaceId: number;
|
|
1381
|
+
id: string;
|
|
1382
|
+
userId: string;
|
|
1383
|
+
name: string;
|
|
1384
|
+
surname: string;
|
|
1385
|
+
email: string;
|
|
1386
|
+
createdAt: any;
|
|
1387
|
+
};
|
|
1388
|
+
};
|
|
1389
|
+
export type AgentsQueryVariables = Exact<{
|
|
1390
|
+
input: AgentsInput;
|
|
1391
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
1392
|
+
}>;
|
|
1393
|
+
export type AgentsQuery = {
|
|
1394
|
+
__typename?: 'Query';
|
|
1395
|
+
agents: {
|
|
1396
|
+
__typename?: 'AgentsPayload';
|
|
1397
|
+
nodes?: Array<{
|
|
1398
|
+
__typename?: 'Agent';
|
|
1399
|
+
workspaceId: number;
|
|
1400
|
+
id: string;
|
|
1401
|
+
userId: string;
|
|
1402
|
+
name: string;
|
|
1403
|
+
surname: string;
|
|
1404
|
+
email: string;
|
|
1405
|
+
createdAt: any;
|
|
1406
|
+
}> | null;
|
|
1407
|
+
pageInfo?: {
|
|
1408
|
+
__typename?: 'PageInfo';
|
|
1409
|
+
hasNextPage: boolean;
|
|
1410
|
+
endCursor?: any | null;
|
|
1411
|
+
count?: number | null;
|
|
1412
|
+
} | null;
|
|
1413
|
+
};
|
|
1414
|
+
};
|
|
1415
|
+
export type AssignConvMutationVariables = Exact<{
|
|
1416
|
+
input: ConvAssignInput;
|
|
1417
|
+
}>;
|
|
1418
|
+
export type AssignConvMutation = {
|
|
1419
|
+
__typename?: 'Mutation';
|
|
1420
|
+
assignConv: {
|
|
1421
|
+
__typename?: 'Conversation';
|
|
1422
|
+
workspaceId: number;
|
|
1423
|
+
id: string;
|
|
1424
|
+
integrationId: string;
|
|
1425
|
+
integrationType: IntegrationType;
|
|
1426
|
+
clientId: string;
|
|
1427
|
+
ended: boolean;
|
|
1428
|
+
externalConversationId?: string | null;
|
|
1429
|
+
tags?: Array<string> | null;
|
|
1430
|
+
createdAt: any;
|
|
1431
|
+
endedAt?: any | null;
|
|
1432
|
+
stageId?: string | null;
|
|
1433
|
+
orderNo?: string | null;
|
|
1434
|
+
assigneeId?: string | null;
|
|
1435
|
+
aiId?: string | null;
|
|
1436
|
+
aiAssigneed?: boolean | null;
|
|
1437
|
+
messages?: Array<{
|
|
1438
|
+
__typename?: 'Message';
|
|
1439
|
+
messageId: string;
|
|
1440
|
+
content: string;
|
|
1441
|
+
type: MessageType;
|
|
1442
|
+
isAgent: boolean;
|
|
1443
|
+
status?: MessageStatus | null;
|
|
1444
|
+
externalMessageId?: string | null;
|
|
1445
|
+
tags?: Array<string> | null;
|
|
1446
|
+
createdAt: any;
|
|
1447
|
+
}> | null;
|
|
1448
|
+
client?: {
|
|
1449
|
+
__typename?: 'ConversationClient';
|
|
1450
|
+
name?: string | null;
|
|
1451
|
+
surname?: string | null;
|
|
1452
|
+
code?: string | null;
|
|
1453
|
+
} | null;
|
|
1454
|
+
assignees?: Array<{
|
|
1455
|
+
__typename?: 'ConvAssignment';
|
|
1456
|
+
assigneeId: string;
|
|
1457
|
+
assignDate?: any | null;
|
|
1458
|
+
isAi?: boolean | null;
|
|
1459
|
+
} | null> | null;
|
|
1460
|
+
};
|
|
1461
|
+
};
|
|
1462
|
+
export type BroadcastQueryVariables = Exact<{
|
|
1463
|
+
input: BroadcastInput;
|
|
1464
|
+
}>;
|
|
1465
|
+
export type BroadcastQuery = {
|
|
1466
|
+
__typename?: 'Query';
|
|
1467
|
+
broadcast: {
|
|
1468
|
+
__typename?: 'Broadcast';
|
|
1469
|
+
workspaceId: number;
|
|
1470
|
+
id: string;
|
|
1471
|
+
name: string;
|
|
1472
|
+
integrationId: string;
|
|
1473
|
+
state: BroadcastState;
|
|
1474
|
+
clientTags?: Array<string> | null;
|
|
1475
|
+
clientStageId?: string | null;
|
|
1476
|
+
templateName: string;
|
|
1477
|
+
templateLang?: string | null;
|
|
1478
|
+
createdAt: any;
|
|
1479
|
+
scheduledAt?: any | null;
|
|
1480
|
+
startedAt?: any | null;
|
|
1481
|
+
completedAt?: any | null;
|
|
1482
|
+
totalCount?: number | null;
|
|
1483
|
+
failedCount?: number | null;
|
|
1484
|
+
error?: string | null;
|
|
1485
|
+
};
|
|
1486
|
+
};
|
|
1487
|
+
export type BroadcastsQueryVariables = Exact<{
|
|
1488
|
+
input: BroadcastsInput;
|
|
1489
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
1490
|
+
}>;
|
|
1491
|
+
export type BroadcastsQuery = {
|
|
1492
|
+
__typename?: 'Query';
|
|
1493
|
+
broadcasts: {
|
|
1494
|
+
__typename?: 'BroadcastsPayload';
|
|
1495
|
+
nodes?: Array<{
|
|
1496
|
+
__typename?: 'Broadcast';
|
|
1497
|
+
workspaceId: number;
|
|
1498
|
+
id: string;
|
|
1499
|
+
name: string;
|
|
1500
|
+
integrationId: string;
|
|
1501
|
+
state: BroadcastState;
|
|
1502
|
+
clientTags?: Array<string> | null;
|
|
1503
|
+
clientStageId?: string | null;
|
|
1504
|
+
templateName: string;
|
|
1505
|
+
templateLang?: string | null;
|
|
1506
|
+
createdAt: any;
|
|
1507
|
+
scheduledAt?: any | null;
|
|
1508
|
+
startedAt?: any | null;
|
|
1509
|
+
completedAt?: any | null;
|
|
1510
|
+
totalCount?: number | null;
|
|
1511
|
+
failedCount?: number | null;
|
|
1512
|
+
error?: string | null;
|
|
1513
|
+
}> | null;
|
|
1514
|
+
pageInfo?: {
|
|
1515
|
+
__typename?: 'PageInfo';
|
|
1516
|
+
hasNextPage: boolean;
|
|
1517
|
+
endCursor?: any | null;
|
|
1518
|
+
count?: number | null;
|
|
1519
|
+
} | null;
|
|
1520
|
+
};
|
|
1521
|
+
};
|
|
1522
|
+
export type ClientQueryVariables = Exact<{
|
|
1523
|
+
input: ClientInput;
|
|
1524
|
+
}>;
|
|
1525
|
+
export type ClientQuery = {
|
|
1526
|
+
__typename?: 'Query';
|
|
1527
|
+
client: {
|
|
1528
|
+
__typename?: 'Client';
|
|
1529
|
+
workspaceId: number;
|
|
1530
|
+
id: string;
|
|
1531
|
+
email?: string | null;
|
|
1532
|
+
name?: string | null;
|
|
1533
|
+
surname?: string | null;
|
|
1534
|
+
phone?: string | null;
|
|
1535
|
+
address?: string | null;
|
|
1536
|
+
code?: string | null;
|
|
1537
|
+
city?: string | null;
|
|
1538
|
+
country?: string | null;
|
|
1539
|
+
externalClientId?: string | null;
|
|
1540
|
+
tags?: Array<string> | null;
|
|
1541
|
+
createdAt: any;
|
|
1542
|
+
stageId?: string | null;
|
|
1543
|
+
};
|
|
1544
|
+
};
|
|
1545
|
+
export type ClientsQueryVariables = Exact<{
|
|
1546
|
+
input: ClientsInput;
|
|
1547
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
1548
|
+
}>;
|
|
1549
|
+
export type ClientsQuery = {
|
|
1550
|
+
__typename?: 'Query';
|
|
1551
|
+
clients: {
|
|
1552
|
+
__typename?: 'ClientsPayload';
|
|
1553
|
+
nodes?: Array<{
|
|
1554
|
+
__typename?: 'Client';
|
|
1555
|
+
workspaceId: number;
|
|
1556
|
+
id: string;
|
|
1557
|
+
email?: string | null;
|
|
1558
|
+
name?: string | null;
|
|
1559
|
+
surname?: string | null;
|
|
1560
|
+
phone?: string | null;
|
|
1561
|
+
address?: string | null;
|
|
1562
|
+
code?: string | null;
|
|
1563
|
+
city?: string | null;
|
|
1564
|
+
country?: string | null;
|
|
1565
|
+
externalClientId?: string | null;
|
|
1566
|
+
tags?: Array<string> | null;
|
|
1567
|
+
createdAt: any;
|
|
1568
|
+
stageId?: string | null;
|
|
1569
|
+
}> | null;
|
|
1570
|
+
pageInfo?: {
|
|
1571
|
+
__typename?: 'PageInfo';
|
|
1572
|
+
hasNextPage: boolean;
|
|
1573
|
+
endCursor?: any | null;
|
|
1574
|
+
count?: number | null;
|
|
1575
|
+
} | null;
|
|
1576
|
+
};
|
|
1577
|
+
};
|
|
1578
|
+
export type ConvsQueryVariables = Exact<{
|
|
1579
|
+
input: ConvsInput;
|
|
1580
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
1581
|
+
}>;
|
|
1582
|
+
export type ConvsQuery = {
|
|
1583
|
+
__typename?: 'Query';
|
|
1584
|
+
convs: {
|
|
1585
|
+
__typename?: 'ConvsPayload';
|
|
1586
|
+
nodes?: Array<{
|
|
1587
|
+
__typename?: 'Conversation';
|
|
1588
|
+
workspaceId: number;
|
|
1589
|
+
id: string;
|
|
1590
|
+
integrationId: string;
|
|
1591
|
+
integrationType: IntegrationType;
|
|
1592
|
+
clientId: string;
|
|
1593
|
+
ended: boolean;
|
|
1594
|
+
externalConversationId?: string | null;
|
|
1595
|
+
tags?: Array<string> | null;
|
|
1596
|
+
createdAt: any;
|
|
1597
|
+
endedAt?: any | null;
|
|
1598
|
+
stageId?: string | null;
|
|
1599
|
+
orderNo?: string | null;
|
|
1600
|
+
assigneeId?: string | null;
|
|
1601
|
+
aiId?: string | null;
|
|
1602
|
+
aiAssigneed?: boolean | null;
|
|
1603
|
+
messages?: Array<{
|
|
1604
|
+
__typename?: 'Message';
|
|
1605
|
+
messageId: string;
|
|
1606
|
+
content: string;
|
|
1607
|
+
type: MessageType;
|
|
1608
|
+
isAgent: boolean;
|
|
1609
|
+
status?: MessageStatus | null;
|
|
1610
|
+
externalMessageId?: string | null;
|
|
1611
|
+
tags?: Array<string> | null;
|
|
1612
|
+
createdAt: any;
|
|
1613
|
+
}> | null;
|
|
1614
|
+
client?: {
|
|
1615
|
+
__typename?: 'ConversationClient';
|
|
1616
|
+
name?: string | null;
|
|
1617
|
+
surname?: string | null;
|
|
1618
|
+
code?: string | null;
|
|
1619
|
+
} | null;
|
|
1620
|
+
assignees?: Array<{
|
|
1621
|
+
__typename?: 'ConvAssignment';
|
|
1622
|
+
assigneeId: string;
|
|
1623
|
+
assignDate?: any | null;
|
|
1624
|
+
isAi?: boolean | null;
|
|
1625
|
+
} | null> | null;
|
|
1626
|
+
}> | null;
|
|
1627
|
+
pageInfo?: {
|
|
1628
|
+
__typename?: 'PageInfo';
|
|
1629
|
+
hasNextPage: boolean;
|
|
1630
|
+
endCursor?: any | null;
|
|
1631
|
+
count?: number | null;
|
|
1632
|
+
} | null;
|
|
1633
|
+
};
|
|
1634
|
+
};
|
|
1635
|
+
export type CreateAgentMutationVariables = Exact<{
|
|
1636
|
+
input: AgentCreateInput;
|
|
1637
|
+
}>;
|
|
1638
|
+
export type CreateAgentMutation = {
|
|
1639
|
+
__typename?: 'Mutation';
|
|
1640
|
+
createAgent: {
|
|
1641
|
+
__typename?: 'Agent';
|
|
1642
|
+
workspaceId: number;
|
|
1643
|
+
id: string;
|
|
1644
|
+
userId: string;
|
|
1645
|
+
name: string;
|
|
1646
|
+
surname: string;
|
|
1647
|
+
email: string;
|
|
1648
|
+
createdAt: any;
|
|
1649
|
+
};
|
|
1650
|
+
};
|
|
1651
|
+
export type CreateBroadcastMutationVariables = Exact<{
|
|
1652
|
+
input: BroadcastCreateInput;
|
|
1653
|
+
}>;
|
|
1654
|
+
export type CreateBroadcastMutation = {
|
|
1655
|
+
__typename?: 'Mutation';
|
|
1656
|
+
createBroadcast: {
|
|
1657
|
+
__typename?: 'Broadcast';
|
|
1658
|
+
workspaceId: number;
|
|
1659
|
+
id: string;
|
|
1660
|
+
name: string;
|
|
1661
|
+
integrationId: string;
|
|
1662
|
+
state: BroadcastState;
|
|
1663
|
+
clientTags?: Array<string> | null;
|
|
1664
|
+
clientStageId?: string | null;
|
|
1665
|
+
templateName: string;
|
|
1666
|
+
templateLang?: string | null;
|
|
1667
|
+
createdAt: any;
|
|
1668
|
+
scheduledAt?: any | null;
|
|
1669
|
+
startedAt?: any | null;
|
|
1670
|
+
completedAt?: any | null;
|
|
1671
|
+
totalCount?: number | null;
|
|
1672
|
+
failedCount?: number | null;
|
|
1673
|
+
error?: string | null;
|
|
1674
|
+
};
|
|
1675
|
+
};
|
|
1676
|
+
export type DeleteAgentMutationVariables = Exact<{
|
|
1677
|
+
input: AgentInput;
|
|
1678
|
+
}>;
|
|
1679
|
+
export type DeleteAgentMutation = {
|
|
1680
|
+
__typename?: 'Mutation';
|
|
1681
|
+
deleteAgent: {
|
|
1682
|
+
__typename?: 'Agent';
|
|
1683
|
+
workspaceId: number;
|
|
1684
|
+
id: string;
|
|
1685
|
+
userId: string;
|
|
1686
|
+
name: string;
|
|
1687
|
+
surname: string;
|
|
1688
|
+
email: string;
|
|
1689
|
+
createdAt: any;
|
|
1690
|
+
};
|
|
1691
|
+
};
|
|
1692
|
+
export type DeleteBroadcastMutationVariables = Exact<{
|
|
1693
|
+
input: BroadcastDeleteInput;
|
|
1694
|
+
}>;
|
|
1695
|
+
export type DeleteBroadcastMutation = {
|
|
1696
|
+
__typename?: 'Mutation';
|
|
1697
|
+
deleteBroadcast: {
|
|
1698
|
+
__typename?: 'Broadcast';
|
|
1699
|
+
workspaceId: number;
|
|
1700
|
+
id: string;
|
|
1701
|
+
name: string;
|
|
1702
|
+
integrationId: string;
|
|
1703
|
+
state: BroadcastState;
|
|
1704
|
+
clientTags?: Array<string> | null;
|
|
1705
|
+
clientStageId?: string | null;
|
|
1706
|
+
templateName: string;
|
|
1707
|
+
templateLang?: string | null;
|
|
1708
|
+
createdAt: any;
|
|
1709
|
+
scheduledAt?: any | null;
|
|
1710
|
+
startedAt?: any | null;
|
|
1711
|
+
completedAt?: any | null;
|
|
1712
|
+
totalCount?: number | null;
|
|
1713
|
+
failedCount?: number | null;
|
|
1714
|
+
error?: string | null;
|
|
1715
|
+
};
|
|
1716
|
+
};
|
|
1717
|
+
export type EndConvMutationVariables = Exact<{
|
|
1718
|
+
input: ConvEndInput;
|
|
1719
|
+
}>;
|
|
1720
|
+
export type EndConvMutation = {
|
|
1721
|
+
__typename?: 'Mutation';
|
|
1722
|
+
endConv: {
|
|
1723
|
+
__typename?: 'Conversation';
|
|
1724
|
+
workspaceId: number;
|
|
1725
|
+
id: string;
|
|
1726
|
+
integrationId: string;
|
|
1727
|
+
integrationType: IntegrationType;
|
|
1728
|
+
clientId: string;
|
|
1729
|
+
ended: boolean;
|
|
1730
|
+
externalConversationId?: string | null;
|
|
1731
|
+
tags?: Array<string> | null;
|
|
1732
|
+
createdAt: any;
|
|
1733
|
+
endedAt?: any | null;
|
|
1734
|
+
stageId?: string | null;
|
|
1735
|
+
orderNo?: string | null;
|
|
1736
|
+
assigneeId?: string | null;
|
|
1737
|
+
aiId?: string | null;
|
|
1738
|
+
aiAssigneed?: boolean | null;
|
|
1739
|
+
messages?: Array<{
|
|
1740
|
+
__typename?: 'Message';
|
|
1741
|
+
messageId: string;
|
|
1742
|
+
content: string;
|
|
1743
|
+
type: MessageType;
|
|
1744
|
+
isAgent: boolean;
|
|
1745
|
+
status?: MessageStatus | null;
|
|
1746
|
+
externalMessageId?: string | null;
|
|
1747
|
+
tags?: Array<string> | null;
|
|
1748
|
+
createdAt: any;
|
|
1749
|
+
}> | null;
|
|
1750
|
+
client?: {
|
|
1751
|
+
__typename?: 'ConversationClient';
|
|
1752
|
+
name?: string | null;
|
|
1753
|
+
surname?: string | null;
|
|
1754
|
+
code?: string | null;
|
|
1755
|
+
} | null;
|
|
1756
|
+
assignees?: Array<{
|
|
1757
|
+
__typename?: 'ConvAssignment';
|
|
1758
|
+
assigneeId: string;
|
|
1759
|
+
assignDate?: any | null;
|
|
1760
|
+
isAi?: boolean | null;
|
|
1761
|
+
} | null> | null;
|
|
1762
|
+
};
|
|
1763
|
+
};
|
|
1764
|
+
export type LaunchBroadcastMutationVariables = Exact<{
|
|
1765
|
+
input: BroadcastLaunchInput;
|
|
1766
|
+
}>;
|
|
1767
|
+
export type LaunchBroadcastMutation = {
|
|
1768
|
+
__typename?: 'Mutation';
|
|
1769
|
+
launchBroadcast: {
|
|
1770
|
+
__typename?: 'Broadcast';
|
|
1771
|
+
workspaceId: number;
|
|
1772
|
+
id: string;
|
|
1773
|
+
name: string;
|
|
1774
|
+
integrationId: string;
|
|
1775
|
+
state: BroadcastState;
|
|
1776
|
+
clientTags?: Array<string> | null;
|
|
1777
|
+
clientStageId?: string | null;
|
|
1778
|
+
templateName: string;
|
|
1779
|
+
templateLang?: string | null;
|
|
1780
|
+
createdAt: any;
|
|
1781
|
+
scheduledAt?: any | null;
|
|
1782
|
+
startedAt?: any | null;
|
|
1783
|
+
completedAt?: any | null;
|
|
1784
|
+
totalCount?: number | null;
|
|
1785
|
+
failedCount?: number | null;
|
|
1786
|
+
error?: string | null;
|
|
1787
|
+
};
|
|
1788
|
+
};
|
|
1789
|
+
export type MessagesQueryVariables = Exact<{
|
|
1790
|
+
input: MessagesInput;
|
|
1791
|
+
pageInfo?: InputMaybe<PageInfoInput>;
|
|
1792
|
+
}>;
|
|
1793
|
+
export type MessagesQuery = {
|
|
1794
|
+
__typename?: 'Query';
|
|
1795
|
+
messages: {
|
|
1796
|
+
__typename?: 'MessagesPayload';
|
|
1797
|
+
nodes?: Array<{
|
|
1798
|
+
__typename?: 'Message';
|
|
1799
|
+
messageId: string;
|
|
1800
|
+
content: string;
|
|
1801
|
+
type: MessageType;
|
|
1802
|
+
isAgent: boolean;
|
|
1803
|
+
status?: MessageStatus | null;
|
|
1804
|
+
externalMessageId?: string | null;
|
|
1805
|
+
tags?: Array<string> | null;
|
|
1806
|
+
createdAt: any;
|
|
1807
|
+
}> | null;
|
|
1808
|
+
pageInfo?: {
|
|
1809
|
+
__typename?: 'PageInfo';
|
|
1810
|
+
hasNextPage: boolean;
|
|
1811
|
+
endCursor?: any | null;
|
|
1812
|
+
count?: number | null;
|
|
1813
|
+
} | null;
|
|
1814
|
+
};
|
|
1815
|
+
};
|
|
1816
|
+
export type PatchAgentMutationVariables = Exact<{
|
|
1817
|
+
input: AgentPatchInput;
|
|
1818
|
+
}>;
|
|
1819
|
+
export type PatchAgentMutation = {
|
|
1820
|
+
__typename?: 'Mutation';
|
|
1821
|
+
patchAgent: {
|
|
1822
|
+
__typename?: 'Agent';
|
|
1823
|
+
workspaceId: number;
|
|
1824
|
+
id: string;
|
|
1825
|
+
userId: string;
|
|
1826
|
+
name: string;
|
|
1827
|
+
surname: string;
|
|
1828
|
+
email: string;
|
|
1829
|
+
createdAt: any;
|
|
1830
|
+
};
|
|
1831
|
+
};
|
|
1832
|
+
export type PatchBroadcastMutationVariables = Exact<{
|
|
1833
|
+
input: BroadcastPatchInput;
|
|
1834
|
+
}>;
|
|
1835
|
+
export type PatchBroadcastMutation = {
|
|
1836
|
+
__typename?: 'Mutation';
|
|
1837
|
+
patchBroadcast: {
|
|
1838
|
+
__typename?: 'Broadcast';
|
|
1839
|
+
workspaceId: number;
|
|
1840
|
+
id: string;
|
|
1841
|
+
name: string;
|
|
1842
|
+
integrationId: string;
|
|
1843
|
+
state: BroadcastState;
|
|
1844
|
+
clientTags?: Array<string> | null;
|
|
1845
|
+
clientStageId?: string | null;
|
|
1846
|
+
templateName: string;
|
|
1847
|
+
templateLang?: string | null;
|
|
1848
|
+
createdAt: any;
|
|
1849
|
+
scheduledAt?: any | null;
|
|
1850
|
+
startedAt?: any | null;
|
|
1851
|
+
completedAt?: any | null;
|
|
1852
|
+
totalCount?: number | null;
|
|
1853
|
+
failedCount?: number | null;
|
|
1854
|
+
error?: string | null;
|
|
1855
|
+
};
|
|
1856
|
+
};
|
|
1857
|
+
export type PatchClientMutationVariables = Exact<{
|
|
1858
|
+
input: ClientPatchInput;
|
|
1859
|
+
}>;
|
|
1860
|
+
export type PatchClientMutation = {
|
|
1861
|
+
__typename?: 'Mutation';
|
|
1862
|
+
patchClient: {
|
|
1863
|
+
__typename?: 'Client';
|
|
1864
|
+
workspaceId: number;
|
|
1865
|
+
id: string;
|
|
1866
|
+
email?: string | null;
|
|
1867
|
+
name?: string | null;
|
|
1868
|
+
surname?: string | null;
|
|
1869
|
+
phone?: string | null;
|
|
1870
|
+
address?: string | null;
|
|
1871
|
+
code?: string | null;
|
|
1872
|
+
city?: string | null;
|
|
1873
|
+
country?: string | null;
|
|
1874
|
+
externalClientId?: string | null;
|
|
1875
|
+
tags?: Array<string> | null;
|
|
1876
|
+
createdAt: any;
|
|
1877
|
+
stageId?: string | null;
|
|
1878
|
+
};
|
|
1879
|
+
};
|
|
1880
|
+
export type PatchConvMutationVariables = Exact<{
|
|
1881
|
+
input: ConvPatchInput;
|
|
1882
|
+
}>;
|
|
1883
|
+
export type PatchConvMutation = {
|
|
1884
|
+
__typename?: 'Mutation';
|
|
1885
|
+
patchConv: {
|
|
1886
|
+
__typename?: 'Conversation';
|
|
1887
|
+
workspaceId: number;
|
|
1888
|
+
id: string;
|
|
1889
|
+
integrationId: string;
|
|
1890
|
+
integrationType: IntegrationType;
|
|
1891
|
+
clientId: string;
|
|
1892
|
+
ended: boolean;
|
|
1893
|
+
externalConversationId?: string | null;
|
|
1894
|
+
tags?: Array<string> | null;
|
|
1895
|
+
createdAt: any;
|
|
1896
|
+
endedAt?: any | null;
|
|
1897
|
+
stageId?: string | null;
|
|
1898
|
+
orderNo?: string | null;
|
|
1899
|
+
assigneeId?: string | null;
|
|
1900
|
+
aiId?: string | null;
|
|
1901
|
+
aiAssigneed?: boolean | null;
|
|
1902
|
+
messages?: Array<{
|
|
1903
|
+
__typename?: 'Message';
|
|
1904
|
+
messageId: string;
|
|
1905
|
+
content: string;
|
|
1906
|
+
type: MessageType;
|
|
1907
|
+
isAgent: boolean;
|
|
1908
|
+
status?: MessageStatus | null;
|
|
1909
|
+
externalMessageId?: string | null;
|
|
1910
|
+
tags?: Array<string> | null;
|
|
1911
|
+
createdAt: any;
|
|
1912
|
+
}> | null;
|
|
1913
|
+
client?: {
|
|
1914
|
+
__typename?: 'ConversationClient';
|
|
1915
|
+
name?: string | null;
|
|
1916
|
+
surname?: string | null;
|
|
1917
|
+
code?: string | null;
|
|
1918
|
+
} | null;
|
|
1919
|
+
assignees?: Array<{
|
|
1920
|
+
__typename?: 'ConvAssignment';
|
|
1921
|
+
assigneeId: string;
|
|
1922
|
+
assignDate?: any | null;
|
|
1923
|
+
isAi?: boolean | null;
|
|
1924
|
+
} | null> | null;
|
|
1925
|
+
};
|
|
1926
|
+
};
|
|
1927
|
+
export type StartConvMutationVariables = Exact<{
|
|
1928
|
+
input: ConvStartInput;
|
|
1929
|
+
}>;
|
|
1930
|
+
export type StartConvMutation = {
|
|
1931
|
+
__typename?: 'Mutation';
|
|
1932
|
+
startConv: {
|
|
1933
|
+
__typename?: 'Conversation';
|
|
1934
|
+
workspaceId: number;
|
|
1935
|
+
id: string;
|
|
1936
|
+
integrationId: string;
|
|
1937
|
+
integrationType: IntegrationType;
|
|
1938
|
+
clientId: string;
|
|
1939
|
+
ended: boolean;
|
|
1940
|
+
externalConversationId?: string | null;
|
|
1941
|
+
tags?: Array<string> | null;
|
|
1942
|
+
createdAt: any;
|
|
1943
|
+
endedAt?: any | null;
|
|
1944
|
+
stageId?: string | null;
|
|
1945
|
+
orderNo?: string | null;
|
|
1946
|
+
assigneeId?: string | null;
|
|
1947
|
+
aiId?: string | null;
|
|
1948
|
+
aiAssigneed?: boolean | null;
|
|
1949
|
+
messages?: Array<{
|
|
1950
|
+
__typename?: 'Message';
|
|
1951
|
+
messageId: string;
|
|
1952
|
+
content: string;
|
|
1953
|
+
type: MessageType;
|
|
1954
|
+
isAgent: boolean;
|
|
1955
|
+
status?: MessageStatus | null;
|
|
1956
|
+
externalMessageId?: string | null;
|
|
1957
|
+
tags?: Array<string> | null;
|
|
1958
|
+
createdAt: any;
|
|
1959
|
+
}> | null;
|
|
1960
|
+
client?: {
|
|
1961
|
+
__typename?: 'ConversationClient';
|
|
1962
|
+
name?: string | null;
|
|
1963
|
+
surname?: string | null;
|
|
1964
|
+
code?: string | null;
|
|
1965
|
+
} | null;
|
|
1966
|
+
assignees?: Array<{
|
|
1967
|
+
__typename?: 'ConvAssignment';
|
|
1968
|
+
assigneeId: string;
|
|
1969
|
+
assignDate?: any | null;
|
|
1970
|
+
isAi?: boolean | null;
|
|
1971
|
+
} | null> | null;
|
|
1972
|
+
};
|
|
1973
|
+
};
|
|
1974
|
+
export type TagClientMutationVariables = Exact<{
|
|
1975
|
+
input: ClientTagInput;
|
|
1976
|
+
}>;
|
|
1977
|
+
export type TagClientMutation = {
|
|
1978
|
+
__typename?: 'Mutation';
|
|
1979
|
+
tagClient: {
|
|
1980
|
+
__typename?: 'Client';
|
|
1981
|
+
workspaceId: number;
|
|
1982
|
+
id: string;
|
|
1983
|
+
email?: string | null;
|
|
1984
|
+
name?: string | null;
|
|
1985
|
+
surname?: string | null;
|
|
1986
|
+
phone?: string | null;
|
|
1987
|
+
address?: string | null;
|
|
1988
|
+
code?: string | null;
|
|
1989
|
+
city?: string | null;
|
|
1990
|
+
country?: string | null;
|
|
1991
|
+
externalClientId?: string | null;
|
|
1992
|
+
tags?: Array<string> | null;
|
|
1993
|
+
createdAt: any;
|
|
1994
|
+
stageId?: string | null;
|
|
1995
|
+
};
|
|
1996
|
+
};
|
|
1997
|
+
export type TagConvMutationVariables = Exact<{
|
|
1998
|
+
input: ConvTagInput;
|
|
1999
|
+
}>;
|
|
2000
|
+
export type TagConvMutation = {
|
|
2001
|
+
__typename?: 'Mutation';
|
|
2002
|
+
tagConv: {
|
|
2003
|
+
__typename?: 'Conversation';
|
|
2004
|
+
workspaceId: number;
|
|
2005
|
+
id: string;
|
|
2006
|
+
integrationId: string;
|
|
2007
|
+
integrationType: IntegrationType;
|
|
2008
|
+
clientId: string;
|
|
2009
|
+
ended: boolean;
|
|
2010
|
+
externalConversationId?: string | null;
|
|
2011
|
+
tags?: Array<string> | null;
|
|
2012
|
+
createdAt: any;
|
|
2013
|
+
endedAt?: any | null;
|
|
2014
|
+
stageId?: string | null;
|
|
2015
|
+
orderNo?: string | null;
|
|
2016
|
+
assigneeId?: string | null;
|
|
2017
|
+
aiId?: string | null;
|
|
2018
|
+
aiAssigneed?: boolean | null;
|
|
2019
|
+
messages?: Array<{
|
|
2020
|
+
__typename?: 'Message';
|
|
2021
|
+
messageId: string;
|
|
2022
|
+
content: string;
|
|
2023
|
+
type: MessageType;
|
|
2024
|
+
isAgent: boolean;
|
|
2025
|
+
status?: MessageStatus | null;
|
|
2026
|
+
externalMessageId?: string | null;
|
|
2027
|
+
tags?: Array<string> | null;
|
|
2028
|
+
createdAt: any;
|
|
2029
|
+
}> | null;
|
|
2030
|
+
client?: {
|
|
2031
|
+
__typename?: 'ConversationClient';
|
|
2032
|
+
name?: string | null;
|
|
2033
|
+
surname?: string | null;
|
|
2034
|
+
code?: string | null;
|
|
2035
|
+
} | null;
|
|
2036
|
+
assignees?: Array<{
|
|
2037
|
+
__typename?: 'ConvAssignment';
|
|
2038
|
+
assigneeId: string;
|
|
2039
|
+
assignDate?: any | null;
|
|
2040
|
+
isAi?: boolean | null;
|
|
2041
|
+
} | null> | null;
|
|
2042
|
+
};
|
|
2043
|
+
};
|
|
2044
|
+
export type TagsQueryVariables = Exact<{
|
|
2045
|
+
input: TagsInput;
|
|
2046
|
+
}>;
|
|
2047
|
+
export type TagsQuery = {
|
|
2048
|
+
__typename?: 'Query';
|
|
2049
|
+
tags: {
|
|
2050
|
+
__typename?: 'TagsPayload';
|
|
2051
|
+
nodes?: Array<{
|
|
2052
|
+
__typename?: 'Tag';
|
|
2053
|
+
id: string;
|
|
2054
|
+
tag: string;
|
|
2055
|
+
type: TagType;
|
|
2056
|
+
createdAt: any;
|
|
2057
|
+
}> | null;
|
|
2058
|
+
};
|
|
2059
|
+
};
|
|
2060
|
+
export type UntagClientMutationVariables = Exact<{
|
|
2061
|
+
input: ClientTagInput;
|
|
2062
|
+
}>;
|
|
2063
|
+
export type UntagClientMutation = {
|
|
2064
|
+
__typename?: 'Mutation';
|
|
2065
|
+
untagClient: {
|
|
2066
|
+
__typename?: 'Client';
|
|
2067
|
+
workspaceId: number;
|
|
2068
|
+
id: string;
|
|
2069
|
+
email?: string | null;
|
|
2070
|
+
name?: string | null;
|
|
2071
|
+
surname?: string | null;
|
|
2072
|
+
phone?: string | null;
|
|
2073
|
+
address?: string | null;
|
|
2074
|
+
code?: string | null;
|
|
2075
|
+
city?: string | null;
|
|
2076
|
+
country?: string | null;
|
|
2077
|
+
externalClientId?: string | null;
|
|
2078
|
+
tags?: Array<string> | null;
|
|
2079
|
+
createdAt: any;
|
|
2080
|
+
stageId?: string | null;
|
|
2081
|
+
};
|
|
2082
|
+
};
|
|
2083
|
+
export type UntagConvMutationVariables = Exact<{
|
|
2084
|
+
input: ConvTagInput;
|
|
2085
|
+
}>;
|
|
2086
|
+
export type UntagConvMutation = {
|
|
2087
|
+
__typename?: 'Mutation';
|
|
2088
|
+
untagConv: {
|
|
2089
|
+
__typename?: 'Conversation';
|
|
2090
|
+
workspaceId: number;
|
|
2091
|
+
id: string;
|
|
2092
|
+
integrationId: string;
|
|
2093
|
+
integrationType: IntegrationType;
|
|
2094
|
+
clientId: string;
|
|
2095
|
+
ended: boolean;
|
|
2096
|
+
externalConversationId?: string | null;
|
|
2097
|
+
tags?: Array<string> | null;
|
|
2098
|
+
createdAt: any;
|
|
2099
|
+
endedAt?: any | null;
|
|
2100
|
+
stageId?: string | null;
|
|
2101
|
+
orderNo?: string | null;
|
|
2102
|
+
assigneeId?: string | null;
|
|
2103
|
+
aiId?: string | null;
|
|
2104
|
+
aiAssigneed?: boolean | null;
|
|
2105
|
+
messages?: Array<{
|
|
2106
|
+
__typename?: 'Message';
|
|
2107
|
+
messageId: string;
|
|
2108
|
+
content: string;
|
|
2109
|
+
type: MessageType;
|
|
2110
|
+
isAgent: boolean;
|
|
2111
|
+
status?: MessageStatus | null;
|
|
2112
|
+
externalMessageId?: string | null;
|
|
2113
|
+
tags?: Array<string> | null;
|
|
2114
|
+
createdAt: any;
|
|
2115
|
+
}> | null;
|
|
2116
|
+
client?: {
|
|
2117
|
+
__typename?: 'ConversationClient';
|
|
2118
|
+
name?: string | null;
|
|
2119
|
+
surname?: string | null;
|
|
2120
|
+
code?: string | null;
|
|
2121
|
+
} | null;
|
|
2122
|
+
assignees?: Array<{
|
|
2123
|
+
__typename?: 'ConvAssignment';
|
|
2124
|
+
assigneeId: string;
|
|
2125
|
+
assignDate?: any | null;
|
|
2126
|
+
isAi?: boolean | null;
|
|
2127
|
+
} | null> | null;
|
|
2128
|
+
};
|
|
2129
|
+
};
|
|
2130
|
+
export type WabaMessageTemplatesQueryVariables = Exact<{
|
|
2131
|
+
input: WabaMessageTemplatesInput;
|
|
2132
|
+
}>;
|
|
2133
|
+
export type WabaMessageTemplatesQuery = {
|
|
2134
|
+
__typename?: 'Query';
|
|
2135
|
+
wabaMessageTemplates: {
|
|
2136
|
+
__typename?: 'MessageTemplatesPayload';
|
|
2137
|
+
nodes?: Array<{
|
|
2138
|
+
__typename?: 'MessageTemplate';
|
|
2139
|
+
id: string;
|
|
2140
|
+
name: string;
|
|
2141
|
+
language: string;
|
|
2142
|
+
status: TemplateState;
|
|
2143
|
+
category: string;
|
|
2144
|
+
library_template_name?: string | null;
|
|
2145
|
+
parameter_format?: string | null;
|
|
2146
|
+
}> | null;
|
|
2147
|
+
};
|
|
2148
|
+
};
|
|
2149
|
+
export type AiFragment = {
|
|
2150
|
+
__typename?: 'AI';
|
|
2151
|
+
workspaceId: number;
|
|
2152
|
+
id: string;
|
|
2153
|
+
name: string;
|
|
2154
|
+
type: AiType;
|
|
2155
|
+
createdAt: any;
|
|
2156
|
+
deletedAt?: any | null;
|
|
2157
|
+
};
|
|
2158
|
+
export type ApiKeyFragment = {
|
|
2159
|
+
__typename?: 'ApiKey';
|
|
2160
|
+
workspaceId: number;
|
|
2161
|
+
id: string;
|
|
2162
|
+
key: string;
|
|
2163
|
+
label: string;
|
|
2164
|
+
createdAt: any;
|
|
2165
|
+
};
|
|
2166
|
+
export type IntegrationFragment = {
|
|
2167
|
+
__typename?: 'Integration';
|
|
2168
|
+
workspaceId: number;
|
|
2169
|
+
id: string;
|
|
2170
|
+
name: string;
|
|
2171
|
+
type: IntegrationType;
|
|
2172
|
+
properties?: any | null;
|
|
2173
|
+
state: IntegrationState;
|
|
2174
|
+
createdAt: any;
|
|
2175
|
+
deletedAt?: any | null;
|
|
2176
|
+
patchedAt?: any | null;
|
|
2177
|
+
};
|
|
2178
|
+
export type WebhookFragment = {
|
|
2179
|
+
__typename?: 'Webhook';
|
|
2180
|
+
workspaceId: number;
|
|
2181
|
+
id: string;
|
|
2182
|
+
label: string;
|
|
2183
|
+
url: string;
|
|
2184
|
+
event: WebhookEvent;
|
|
2185
|
+
createdAt: any;
|
|
2186
|
+
};
|
|
2187
|
+
export type AiQueryVariables = Exact<{
|
|
2188
|
+
input: AiInput;
|
|
2189
|
+
}>;
|
|
2190
|
+
export type AiQuery = {
|
|
2191
|
+
__typename?: 'Query';
|
|
2192
|
+
ai: {
|
|
2193
|
+
__typename?: 'AI';
|
|
2194
|
+
workspaceId: number;
|
|
2195
|
+
id: string;
|
|
2196
|
+
name: string;
|
|
2197
|
+
type: AiType;
|
|
2198
|
+
createdAt: any;
|
|
2199
|
+
deletedAt?: any | null;
|
|
2200
|
+
};
|
|
2201
|
+
};
|
|
2202
|
+
export type AisQueryVariables = Exact<{
|
|
2203
|
+
input: AIsInput;
|
|
2204
|
+
}>;
|
|
2205
|
+
export type AisQuery = {
|
|
2206
|
+
__typename?: 'Query';
|
|
2207
|
+
ais: {
|
|
2208
|
+
__typename?: 'AIsPayload';
|
|
2209
|
+
nodes?: Array<{
|
|
2210
|
+
__typename?: 'AI';
|
|
2211
|
+
workspaceId: number;
|
|
2212
|
+
id: string;
|
|
2213
|
+
name: string;
|
|
2214
|
+
type: AiType;
|
|
2215
|
+
createdAt: any;
|
|
2216
|
+
deletedAt?: any | null;
|
|
2217
|
+
}> | null;
|
|
2218
|
+
};
|
|
2219
|
+
};
|
|
2220
|
+
export type ApiKeysQueryVariables = Exact<{
|
|
2221
|
+
input: ApiKeysInput;
|
|
2222
|
+
}>;
|
|
2223
|
+
export type ApiKeysQuery = {
|
|
2224
|
+
__typename?: 'Query';
|
|
2225
|
+
apiKeys: {
|
|
2226
|
+
__typename?: 'ApiKeysPayload';
|
|
2227
|
+
nodes?: Array<{
|
|
2228
|
+
__typename?: 'ApiKey';
|
|
2229
|
+
workspaceId: number;
|
|
2230
|
+
id: string;
|
|
2231
|
+
key: string;
|
|
2232
|
+
label: string;
|
|
2233
|
+
createdAt: any;
|
|
2234
|
+
}> | null;
|
|
2235
|
+
};
|
|
2236
|
+
};
|
|
2237
|
+
export type BulkPatchTagsMutationVariables = Exact<{
|
|
2238
|
+
input: TagBulkPatchInput;
|
|
2239
|
+
}>;
|
|
2240
|
+
export type BulkPatchTagsMutation = {
|
|
2241
|
+
__typename?: 'Mutation';
|
|
2242
|
+
bulkPatchTags: never;
|
|
2243
|
+
};
|
|
2244
|
+
export type CreateAiMutationVariables = Exact<{
|
|
2245
|
+
input: AiCreateInput;
|
|
2246
|
+
}>;
|
|
2247
|
+
export type CreateAiMutation = {
|
|
2248
|
+
__typename?: 'Mutation';
|
|
2249
|
+
createAi: {
|
|
2250
|
+
__typename?: 'AI';
|
|
2251
|
+
workspaceId: number;
|
|
2252
|
+
id: string;
|
|
2253
|
+
name: string;
|
|
2254
|
+
type: AiType;
|
|
2255
|
+
createdAt: any;
|
|
2256
|
+
deletedAt?: any | null;
|
|
2257
|
+
};
|
|
2258
|
+
};
|
|
2259
|
+
export type CreateIntegrationMutationVariables = Exact<{
|
|
2260
|
+
input: IntegrationCreateInput;
|
|
2261
|
+
}>;
|
|
2262
|
+
export type CreateIntegrationMutation = {
|
|
2263
|
+
__typename?: 'Mutation';
|
|
2264
|
+
createIntegration: {
|
|
2265
|
+
__typename?: 'Integration';
|
|
2266
|
+
workspaceId: number;
|
|
2267
|
+
id: string;
|
|
2268
|
+
name: string;
|
|
2269
|
+
type: IntegrationType;
|
|
2270
|
+
properties?: any | null;
|
|
2271
|
+
state: IntegrationState;
|
|
2272
|
+
createdAt: any;
|
|
2273
|
+
deletedAt?: any | null;
|
|
2274
|
+
patchedAt?: any | null;
|
|
2275
|
+
};
|
|
2276
|
+
};
|
|
2277
|
+
export type CreateTagMutationVariables = Exact<{
|
|
2278
|
+
input: TagCreateInput;
|
|
2279
|
+
}>;
|
|
2280
|
+
export type CreateTagMutation = {
|
|
2281
|
+
__typename?: 'Mutation';
|
|
2282
|
+
createTag: {
|
|
2283
|
+
__typename?: 'Tag';
|
|
2284
|
+
id: string;
|
|
2285
|
+
tag: string;
|
|
2286
|
+
type: TagType;
|
|
2287
|
+
createdAt: any;
|
|
2288
|
+
};
|
|
2289
|
+
};
|
|
2290
|
+
export type CreateWebhookMutationVariables = Exact<{
|
|
2291
|
+
input: WebhookCreateInput;
|
|
2292
|
+
}>;
|
|
2293
|
+
export type CreateWebhookMutation = {
|
|
2294
|
+
__typename?: 'Mutation';
|
|
2295
|
+
createWebhook: {
|
|
2296
|
+
__typename?: 'Webhook';
|
|
2297
|
+
workspaceId: number;
|
|
2298
|
+
id: string;
|
|
2299
|
+
label: string;
|
|
2300
|
+
url: string;
|
|
2301
|
+
event: WebhookEvent;
|
|
2302
|
+
createdAt: any;
|
|
2303
|
+
};
|
|
2304
|
+
};
|
|
2305
|
+
export type DeleteAiMutationVariables = Exact<{
|
|
2306
|
+
input: AiDeleteInput;
|
|
2307
|
+
}>;
|
|
2308
|
+
export type DeleteAiMutation = {
|
|
2309
|
+
__typename?: 'Mutation';
|
|
2310
|
+
deleteAi: {
|
|
2311
|
+
__typename?: 'AI';
|
|
2312
|
+
workspaceId: number;
|
|
2313
|
+
id: string;
|
|
2314
|
+
name: string;
|
|
2315
|
+
type: AiType;
|
|
2316
|
+
createdAt: any;
|
|
2317
|
+
deletedAt?: any | null;
|
|
2318
|
+
};
|
|
2319
|
+
};
|
|
2320
|
+
export type DeleteApiKeyMutationVariables = Exact<{
|
|
2321
|
+
input: ApiKeyDeleteInput;
|
|
2322
|
+
}>;
|
|
2323
|
+
export type DeleteApiKeyMutation = {
|
|
2324
|
+
__typename?: 'Mutation';
|
|
2325
|
+
deleteApiKey: {
|
|
2326
|
+
__typename?: 'ApiKey';
|
|
2327
|
+
workspaceId: number;
|
|
2328
|
+
id: string;
|
|
2329
|
+
key: string;
|
|
2330
|
+
label: string;
|
|
2331
|
+
createdAt: any;
|
|
2332
|
+
};
|
|
2333
|
+
};
|
|
2334
|
+
export type DeleteIntegrationMutationVariables = Exact<{
|
|
2335
|
+
input: IntegrationDeleteInput;
|
|
2336
|
+
}>;
|
|
2337
|
+
export type DeleteIntegrationMutation = {
|
|
2338
|
+
__typename?: 'Mutation';
|
|
2339
|
+
deleteIntegration: {
|
|
2340
|
+
__typename?: 'Integration';
|
|
2341
|
+
workspaceId: number;
|
|
2342
|
+
id: string;
|
|
2343
|
+
name: string;
|
|
2344
|
+
type: IntegrationType;
|
|
2345
|
+
properties?: any | null;
|
|
2346
|
+
state: IntegrationState;
|
|
2347
|
+
createdAt: any;
|
|
2348
|
+
deletedAt?: any | null;
|
|
2349
|
+
patchedAt?: any | null;
|
|
2350
|
+
};
|
|
2351
|
+
};
|
|
2352
|
+
export type DeleteTagMutationVariables = Exact<{
|
|
2353
|
+
input: TagDeleteInput;
|
|
2354
|
+
}>;
|
|
2355
|
+
export type DeleteTagMutation = {
|
|
2356
|
+
__typename?: 'Mutation';
|
|
2357
|
+
deleteTag: {
|
|
2358
|
+
__typename?: 'Tag';
|
|
2359
|
+
id: string;
|
|
2360
|
+
tag: string;
|
|
2361
|
+
type: TagType;
|
|
2362
|
+
createdAt: any;
|
|
2363
|
+
};
|
|
2364
|
+
};
|
|
2365
|
+
export type DeleteWebhookMutationVariables = Exact<{
|
|
2366
|
+
input: WebhookDeleteInput;
|
|
2367
|
+
}>;
|
|
2368
|
+
export type DeleteWebhookMutation = {
|
|
2369
|
+
__typename?: 'Mutation';
|
|
2370
|
+
deleteWebhook: {
|
|
2371
|
+
__typename?: 'Webhook';
|
|
2372
|
+
workspaceId: number;
|
|
2373
|
+
id: string;
|
|
2374
|
+
label: string;
|
|
2375
|
+
url: string;
|
|
2376
|
+
event: WebhookEvent;
|
|
2377
|
+
createdAt: any;
|
|
2378
|
+
};
|
|
2379
|
+
};
|
|
2380
|
+
export type GenApiKeyMutationVariables = Exact<{
|
|
2381
|
+
input: ApiKeyGenInput;
|
|
2382
|
+
}>;
|
|
2383
|
+
export type GenApiKeyMutation = {
|
|
2384
|
+
__typename?: 'Mutation';
|
|
2385
|
+
genApiKey: {
|
|
2386
|
+
__typename?: 'ApiKey';
|
|
2387
|
+
workspaceId: number;
|
|
2388
|
+
id: string;
|
|
2389
|
+
key: string;
|
|
2390
|
+
label: string;
|
|
2391
|
+
createdAt: any;
|
|
2392
|
+
};
|
|
2393
|
+
};
|
|
2394
|
+
export type IntegrationQueryVariables = Exact<{
|
|
2395
|
+
input: IntegrationInput;
|
|
2396
|
+
}>;
|
|
2397
|
+
export type IntegrationQuery = {
|
|
2398
|
+
__typename?: 'Query';
|
|
2399
|
+
integration: {
|
|
2400
|
+
__typename?: 'Integration';
|
|
2401
|
+
workspaceId: number;
|
|
2402
|
+
id: string;
|
|
2403
|
+
name: string;
|
|
2404
|
+
type: IntegrationType;
|
|
2405
|
+
properties?: any | null;
|
|
2406
|
+
state: IntegrationState;
|
|
2407
|
+
createdAt: any;
|
|
2408
|
+
deletedAt?: any | null;
|
|
2409
|
+
patchedAt?: any | null;
|
|
2410
|
+
};
|
|
2411
|
+
};
|
|
2412
|
+
export type IntegrationsQueryVariables = Exact<{
|
|
2413
|
+
input: IntegrationsInput;
|
|
2414
|
+
}>;
|
|
2415
|
+
export type IntegrationsQuery = {
|
|
2416
|
+
__typename?: 'Query';
|
|
2417
|
+
integrations: {
|
|
2418
|
+
__typename?: 'IntegrationsPayload';
|
|
2419
|
+
nodes?: Array<{
|
|
2420
|
+
__typename?: 'Integration';
|
|
2421
|
+
workspaceId: number;
|
|
2422
|
+
id: string;
|
|
2423
|
+
name: string;
|
|
2424
|
+
type: IntegrationType;
|
|
2425
|
+
properties?: any | null;
|
|
2426
|
+
state: IntegrationState;
|
|
2427
|
+
createdAt: any;
|
|
2428
|
+
deletedAt?: any | null;
|
|
2429
|
+
patchedAt?: any | null;
|
|
2430
|
+
}> | null;
|
|
2431
|
+
};
|
|
2432
|
+
};
|
|
2433
|
+
export type PatchAiMutationVariables = Exact<{
|
|
2434
|
+
input: AiPatchInput;
|
|
2435
|
+
}>;
|
|
2436
|
+
export type PatchAiMutation = {
|
|
2437
|
+
__typename?: 'Mutation';
|
|
2438
|
+
patchAi: {
|
|
2439
|
+
__typename?: 'AI';
|
|
2440
|
+
workspaceId: number;
|
|
2441
|
+
id: string;
|
|
2442
|
+
name: string;
|
|
2443
|
+
type: AiType;
|
|
2444
|
+
createdAt: any;
|
|
2445
|
+
deletedAt?: any | null;
|
|
2446
|
+
};
|
|
2447
|
+
};
|
|
2448
|
+
export type PatchIntegrationMutationVariables = Exact<{
|
|
2449
|
+
input: IntegrationPatchInput;
|
|
2450
|
+
}>;
|
|
2451
|
+
export type PatchIntegrationMutation = {
|
|
2452
|
+
__typename?: 'Mutation';
|
|
2453
|
+
patchIntegration: {
|
|
2454
|
+
__typename?: 'Integration';
|
|
2455
|
+
workspaceId: number;
|
|
2456
|
+
id: string;
|
|
2457
|
+
name: string;
|
|
2458
|
+
type: IntegrationType;
|
|
2459
|
+
properties?: any | null;
|
|
2460
|
+
state: IntegrationState;
|
|
2461
|
+
createdAt: any;
|
|
2462
|
+
deletedAt?: any | null;
|
|
2463
|
+
patchedAt?: any | null;
|
|
2464
|
+
};
|
|
2465
|
+
};
|
|
2466
|
+
export type WebhooksQueryVariables = Exact<{
|
|
2467
|
+
input: WebhooksInput;
|
|
2468
|
+
}>;
|
|
2469
|
+
export type WebhooksQuery = {
|
|
2470
|
+
__typename?: 'Query';
|
|
2471
|
+
webhooks: {
|
|
2472
|
+
__typename?: 'WebhooksPayload';
|
|
2473
|
+
nodes?: Array<{
|
|
2474
|
+
__typename?: 'Webhook';
|
|
2475
|
+
workspaceId: number;
|
|
2476
|
+
id: string;
|
|
2477
|
+
label: string;
|
|
2478
|
+
url: string;
|
|
2479
|
+
event: WebhookEvent;
|
|
2480
|
+
createdAt: any;
|
|
2481
|
+
}> | null;
|
|
2482
|
+
};
|
|
2483
|
+
};
|
|
2484
|
+
export declare const UserRoleFragmentDoc: Apollo.DocumentNode;
|
|
2485
|
+
export declare const AgentReportFragmentDoc: Apollo.DocumentNode;
|
|
2486
|
+
export declare const ConversationReportFragmentDoc: Apollo.DocumentNode;
|
|
2487
|
+
export declare const PageInfoFragmentDoc: Apollo.DocumentNode;
|
|
2488
|
+
export declare const AgentFragmentDoc: Apollo.DocumentNode;
|
|
2489
|
+
export declare const BroadcastFragmentDoc: Apollo.DocumentNode;
|
|
2490
|
+
export declare const ClientFragmentDoc: Apollo.DocumentNode;
|
|
2491
|
+
export declare const MessageFragmentDoc: Apollo.DocumentNode;
|
|
2492
|
+
export declare const ConversationFragmentDoc: Apollo.DocumentNode;
|
|
2493
|
+
export declare const TagFragmentDoc: Apollo.DocumentNode;
|
|
2494
|
+
export declare const MessageTemplateFragmentDoc: Apollo.DocumentNode;
|
|
2495
|
+
export declare const AiFragmentDoc: Apollo.DocumentNode;
|
|
2496
|
+
export declare const ApiKeyFragmentDoc: Apollo.DocumentNode;
|
|
2497
|
+
export declare const IntegrationFragmentDoc: Apollo.DocumentNode;
|
|
2498
|
+
export declare const WebhookFragmentDoc: Apollo.DocumentNode;
|
|
2499
|
+
export declare const AssignOwnerDocument: Apollo.DocumentNode;
|
|
2500
|
+
export type AssignOwnerMutationFn = Apollo.MutationFunction<AssignOwnerMutation, AssignOwnerMutationVariables>;
|
|
2501
|
+
/**
|
|
2502
|
+
* __useAssignOwnerMutation__
|
|
2503
|
+
*
|
|
2504
|
+
* To run a mutation, you first call `useAssignOwnerMutation` within a React component and pass it any options that fit your needs.
|
|
2505
|
+
* When your component renders, `useAssignOwnerMutation` returns a tuple that includes:
|
|
2506
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2507
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2508
|
+
*
|
|
2509
|
+
* @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;
|
|
2510
|
+
*
|
|
2511
|
+
* @example
|
|
2512
|
+
* const [assignOwnerMutation, { data, loading, error }] = useAssignOwnerMutation({
|
|
2513
|
+
* variables: {
|
|
2514
|
+
* input: // value for 'input'
|
|
2515
|
+
* },
|
|
2516
|
+
* });
|
|
2517
|
+
*/
|
|
2518
|
+
export declare function useAssignOwnerMutation(baseOptions?: Apollo.MutationHookOptions<AssignOwnerMutation, AssignOwnerMutationVariables>): Apollo.MutationTuple<AssignOwnerMutation, Exact<{
|
|
2519
|
+
input: InputAssignUserOwner;
|
|
2520
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
2521
|
+
export type AssignOwnerMutationHookResult = ReturnType<typeof useAssignOwnerMutation>;
|
|
2522
|
+
export type AssignOwnerMutationResult = Apollo.MutationResult<AssignOwnerMutation>;
|
|
2523
|
+
export type AssignOwnerMutationOptions = Apollo.BaseMutationOptions<AssignOwnerMutation, AssignOwnerMutationVariables>;
|
|
2524
|
+
export declare const AssignUserRoleDocument: Apollo.DocumentNode;
|
|
2525
|
+
export type AssignUserRoleMutationFn = Apollo.MutationFunction<AssignUserRoleMutation, AssignUserRoleMutationVariables>;
|
|
2526
|
+
/**
|
|
2527
|
+
* __useAssignUserRoleMutation__
|
|
2528
|
+
*
|
|
2529
|
+
* To run a mutation, you first call `useAssignUserRoleMutation` within a React component and pass it any options that fit your needs.
|
|
2530
|
+
* When your component renders, `useAssignUserRoleMutation` returns a tuple that includes:
|
|
2531
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2532
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2533
|
+
*
|
|
2534
|
+
* @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;
|
|
2535
|
+
*
|
|
2536
|
+
* @example
|
|
2537
|
+
* const [assignUserRoleMutation, { data, loading, error }] = useAssignUserRoleMutation({
|
|
2538
|
+
* variables: {
|
|
2539
|
+
* input: // value for 'input'
|
|
2540
|
+
* },
|
|
2541
|
+
* });
|
|
2542
|
+
*/
|
|
2543
|
+
export declare function useAssignUserRoleMutation(baseOptions?: Apollo.MutationHookOptions<AssignUserRoleMutation, AssignUserRoleMutationVariables>): Apollo.MutationTuple<AssignUserRoleMutation, Exact<{
|
|
2544
|
+
input: InputAssignUserRole;
|
|
2545
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
2546
|
+
export type AssignUserRoleMutationHookResult = ReturnType<typeof useAssignUserRoleMutation>;
|
|
2547
|
+
export type AssignUserRoleMutationResult = Apollo.MutationResult<AssignUserRoleMutation>;
|
|
2548
|
+
export type AssignUserRoleMutationOptions = Apollo.BaseMutationOptions<AssignUserRoleMutation, AssignUserRoleMutationVariables>;
|
|
2549
|
+
export declare const InitWorkspaceDocument: Apollo.DocumentNode;
|
|
2550
|
+
export type InitWorkspaceMutationFn = Apollo.MutationFunction<InitWorkspaceMutation, InitWorkspaceMutationVariables>;
|
|
2551
|
+
/**
|
|
2552
|
+
* __useInitWorkspaceMutation__
|
|
2553
|
+
*
|
|
2554
|
+
* To run a mutation, you first call `useInitWorkspaceMutation` within a React component and pass it any options that fit your needs.
|
|
2555
|
+
* When your component renders, `useInitWorkspaceMutation` returns a tuple that includes:
|
|
2556
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2557
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2558
|
+
*
|
|
2559
|
+
* @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;
|
|
2560
|
+
*
|
|
2561
|
+
* @example
|
|
2562
|
+
* const [initWorkspaceMutation, { data, loading, error }] = useInitWorkspaceMutation({
|
|
2563
|
+
* variables: {
|
|
2564
|
+
* input: // value for 'input'
|
|
2565
|
+
* },
|
|
2566
|
+
* });
|
|
2567
|
+
*/
|
|
2568
|
+
export declare function useInitWorkspaceMutation(baseOptions?: Apollo.MutationHookOptions<InitWorkspaceMutation, InitWorkspaceMutationVariables>): Apollo.MutationTuple<InitWorkspaceMutation, Exact<{
|
|
2569
|
+
input: InputInitWorkspace;
|
|
2570
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
2571
|
+
export type InitWorkspaceMutationHookResult = ReturnType<typeof useInitWorkspaceMutation>;
|
|
2572
|
+
export type InitWorkspaceMutationResult = Apollo.MutationResult<InitWorkspaceMutation>;
|
|
2573
|
+
export type InitWorkspaceMutationOptions = Apollo.BaseMutationOptions<InitWorkspaceMutation, InitWorkspaceMutationVariables>;
|
|
2574
|
+
export declare const MeDocument: Apollo.DocumentNode;
|
|
2575
|
+
/**
|
|
2576
|
+
* __useMeQuery__
|
|
2577
|
+
*
|
|
2578
|
+
* To run a query within a React component, call `useMeQuery` and pass it any options that fit your needs.
|
|
2579
|
+
* When your component renders, `useMeQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2580
|
+
* you can use to render your UI.
|
|
2581
|
+
*
|
|
2582
|
+
* @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;
|
|
2583
|
+
*
|
|
2584
|
+
* @example
|
|
2585
|
+
* const { data, loading, error } = useMeQuery({
|
|
2586
|
+
* variables: {
|
|
2587
|
+
* input: // value for 'input'
|
|
2588
|
+
* },
|
|
2589
|
+
* });
|
|
2590
|
+
*/
|
|
2591
|
+
export declare function useMeQuery(baseOptions: Apollo.QueryHookOptions<MeQuery, MeQueryVariables> & ({
|
|
2592
|
+
variables: MeQueryVariables;
|
|
2593
|
+
skip?: boolean;
|
|
2594
|
+
} | {
|
|
2595
|
+
skip: boolean;
|
|
2596
|
+
})): Apollo.QueryResult<MeQuery, Exact<{
|
|
2597
|
+
input: InputInitWorkspace;
|
|
2598
|
+
}>>;
|
|
2599
|
+
export declare function useMeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MeQuery, MeQueryVariables>): Apollo.LazyQueryResultTuple<MeQuery, Exact<{
|
|
2600
|
+
input: InputInitWorkspace;
|
|
2601
|
+
}>>;
|
|
2602
|
+
export declare function useMeSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<MeQuery, MeQueryVariables>): Apollo.UseSuspenseQueryResult<MeQuery | undefined, Exact<{
|
|
2603
|
+
input: InputInitWorkspace;
|
|
2604
|
+
}>>;
|
|
2605
|
+
export type MeQueryHookResult = ReturnType<typeof useMeQuery>;
|
|
2606
|
+
export type MeLazyQueryHookResult = ReturnType<typeof useMeLazyQuery>;
|
|
2607
|
+
export type MeSuspenseQueryHookResult = ReturnType<typeof useMeSuspenseQuery>;
|
|
2608
|
+
export type MeQueryResult = Apollo.QueryResult<MeQuery, MeQueryVariables>;
|
|
2609
|
+
export declare function refetchMeQuery(variables: MeQueryVariables): {
|
|
2610
|
+
query: Apollo.DocumentNode;
|
|
2611
|
+
variables: Exact<{
|
|
2612
|
+
input: InputInitWorkspace;
|
|
2613
|
+
}>;
|
|
2614
|
+
};
|
|
2615
|
+
export declare const UsersRolesDocument: Apollo.DocumentNode;
|
|
2616
|
+
/**
|
|
2617
|
+
* __useUsersRolesQuery__
|
|
2618
|
+
*
|
|
2619
|
+
* To run a query within a React component, call `useUsersRolesQuery` and pass it any options that fit your needs.
|
|
2620
|
+
* When your component renders, `useUsersRolesQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2621
|
+
* you can use to render your UI.
|
|
2622
|
+
*
|
|
2623
|
+
* @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;
|
|
2624
|
+
*
|
|
2625
|
+
* @example
|
|
2626
|
+
* const { data, loading, error } = useUsersRolesQuery({
|
|
2627
|
+
* variables: {
|
|
2628
|
+
* input: // value for 'input'
|
|
2629
|
+
* },
|
|
2630
|
+
* });
|
|
2631
|
+
*/
|
|
2632
|
+
export declare function useUsersRolesQuery(baseOptions: Apollo.QueryHookOptions<UsersRolesQuery, UsersRolesQueryVariables> & ({
|
|
2633
|
+
variables: UsersRolesQueryVariables;
|
|
2634
|
+
skip?: boolean;
|
|
2635
|
+
} | {
|
|
2636
|
+
skip: boolean;
|
|
2637
|
+
})): Apollo.QueryResult<UsersRolesQuery, Exact<{
|
|
2638
|
+
input: InputUsersRoles;
|
|
2639
|
+
}>>;
|
|
2640
|
+
export declare function useUsersRolesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UsersRolesQuery, UsersRolesQueryVariables>): Apollo.LazyQueryResultTuple<UsersRolesQuery, Exact<{
|
|
2641
|
+
input: InputUsersRoles;
|
|
2642
|
+
}>>;
|
|
2643
|
+
export declare function useUsersRolesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<UsersRolesQuery, UsersRolesQueryVariables>): Apollo.UseSuspenseQueryResult<UsersRolesQuery | undefined, Exact<{
|
|
2644
|
+
input: InputUsersRoles;
|
|
2645
|
+
}>>;
|
|
2646
|
+
export type UsersRolesQueryHookResult = ReturnType<typeof useUsersRolesQuery>;
|
|
2647
|
+
export type UsersRolesLazyQueryHookResult = ReturnType<typeof useUsersRolesLazyQuery>;
|
|
2648
|
+
export type UsersRolesSuspenseQueryHookResult = ReturnType<typeof useUsersRolesSuspenseQuery>;
|
|
2649
|
+
export type UsersRolesQueryResult = Apollo.QueryResult<UsersRolesQuery, UsersRolesQueryVariables>;
|
|
2650
|
+
export declare function refetchUsersRolesQuery(variables: UsersRolesQueryVariables): {
|
|
2651
|
+
query: Apollo.DocumentNode;
|
|
2652
|
+
variables: Exact<{
|
|
2653
|
+
input: InputUsersRoles;
|
|
2654
|
+
}>;
|
|
2655
|
+
};
|
|
2656
|
+
export declare const AgentsReportDocument: Apollo.DocumentNode;
|
|
2657
|
+
/**
|
|
2658
|
+
* __useAgentsReportQuery__
|
|
2659
|
+
*
|
|
2660
|
+
* To run a query within a React component, call `useAgentsReportQuery` and pass it any options that fit your needs.
|
|
2661
|
+
* When your component renders, `useAgentsReportQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2662
|
+
* you can use to render your UI.
|
|
2663
|
+
*
|
|
2664
|
+
* @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;
|
|
2665
|
+
*
|
|
2666
|
+
* @example
|
|
2667
|
+
* const { data, loading, error } = useAgentsReportQuery({
|
|
2668
|
+
* variables: {
|
|
2669
|
+
* input: // value for 'input'
|
|
2670
|
+
* },
|
|
2671
|
+
* });
|
|
2672
|
+
*/
|
|
2673
|
+
export declare function useAgentsReportQuery(baseOptions: Apollo.QueryHookOptions<AgentsReportQuery, AgentsReportQueryVariables> & ({
|
|
2674
|
+
variables: AgentsReportQueryVariables;
|
|
2675
|
+
skip?: boolean;
|
|
2676
|
+
} | {
|
|
2677
|
+
skip: boolean;
|
|
2678
|
+
})): Apollo.QueryResult<AgentsReportQuery, Exact<{
|
|
2679
|
+
input: AgentsReportInput;
|
|
2680
|
+
}>>;
|
|
2681
|
+
export declare function useAgentsReportLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AgentsReportQuery, AgentsReportQueryVariables>): Apollo.LazyQueryResultTuple<AgentsReportQuery, Exact<{
|
|
2682
|
+
input: AgentsReportInput;
|
|
2683
|
+
}>>;
|
|
2684
|
+
export declare function useAgentsReportSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AgentsReportQuery, AgentsReportQueryVariables>): Apollo.UseSuspenseQueryResult<AgentsReportQuery | undefined, Exact<{
|
|
2685
|
+
input: AgentsReportInput;
|
|
2686
|
+
}>>;
|
|
2687
|
+
export type AgentsReportQueryHookResult = ReturnType<typeof useAgentsReportQuery>;
|
|
2688
|
+
export type AgentsReportLazyQueryHookResult = ReturnType<typeof useAgentsReportLazyQuery>;
|
|
2689
|
+
export type AgentsReportSuspenseQueryHookResult = ReturnType<typeof useAgentsReportSuspenseQuery>;
|
|
2690
|
+
export type AgentsReportQueryResult = Apollo.QueryResult<AgentsReportQuery, AgentsReportQueryVariables>;
|
|
2691
|
+
export declare function refetchAgentsReportQuery(variables: AgentsReportQueryVariables): {
|
|
2692
|
+
query: Apollo.DocumentNode;
|
|
2693
|
+
variables: Exact<{
|
|
2694
|
+
input: AgentsReportInput;
|
|
2695
|
+
}>;
|
|
2696
|
+
};
|
|
2697
|
+
export declare const ConvsReportDocument: Apollo.DocumentNode;
|
|
2698
|
+
/**
|
|
2699
|
+
* __useConvsReportQuery__
|
|
2700
|
+
*
|
|
2701
|
+
* To run a query within a React component, call `useConvsReportQuery` and pass it any options that fit your needs.
|
|
2702
|
+
* When your component renders, `useConvsReportQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2703
|
+
* you can use to render your UI.
|
|
2704
|
+
*
|
|
2705
|
+
* @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;
|
|
2706
|
+
*
|
|
2707
|
+
* @example
|
|
2708
|
+
* const { data, loading, error } = useConvsReportQuery({
|
|
2709
|
+
* variables: {
|
|
2710
|
+
* input: // value for 'input'
|
|
2711
|
+
* },
|
|
2712
|
+
* });
|
|
2713
|
+
*/
|
|
2714
|
+
export declare function useConvsReportQuery(baseOptions: Apollo.QueryHookOptions<ConvsReportQuery, ConvsReportQueryVariables> & ({
|
|
2715
|
+
variables: ConvsReportQueryVariables;
|
|
2716
|
+
skip?: boolean;
|
|
2717
|
+
} | {
|
|
2718
|
+
skip: boolean;
|
|
2719
|
+
})): Apollo.QueryResult<ConvsReportQuery, Exact<{
|
|
2720
|
+
input: ConvsReportInput;
|
|
2721
|
+
}>>;
|
|
2722
|
+
export declare function useConvsReportLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ConvsReportQuery, ConvsReportQueryVariables>): Apollo.LazyQueryResultTuple<ConvsReportQuery, Exact<{
|
|
2723
|
+
input: ConvsReportInput;
|
|
2724
|
+
}>>;
|
|
2725
|
+
export declare function useConvsReportSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ConvsReportQuery, ConvsReportQueryVariables>): Apollo.UseSuspenseQueryResult<ConvsReportQuery | undefined, Exact<{
|
|
2726
|
+
input: ConvsReportInput;
|
|
2727
|
+
}>>;
|
|
2728
|
+
export type ConvsReportQueryHookResult = ReturnType<typeof useConvsReportQuery>;
|
|
2729
|
+
export type ConvsReportLazyQueryHookResult = ReturnType<typeof useConvsReportLazyQuery>;
|
|
2730
|
+
export type ConvsReportSuspenseQueryHookResult = ReturnType<typeof useConvsReportSuspenseQuery>;
|
|
2731
|
+
export type ConvsReportQueryResult = Apollo.QueryResult<ConvsReportQuery, ConvsReportQueryVariables>;
|
|
2732
|
+
export declare function refetchConvsReportQuery(variables: ConvsReportQueryVariables): {
|
|
2733
|
+
query: Apollo.DocumentNode;
|
|
2734
|
+
variables: Exact<{
|
|
2735
|
+
input: ConvsReportInput;
|
|
2736
|
+
}>;
|
|
2737
|
+
};
|
|
2738
|
+
export declare const AddMessageDocument: Apollo.DocumentNode;
|
|
2739
|
+
export type AddMessageMutationFn = Apollo.MutationFunction<AddMessageMutation, AddMessageMutationVariables>;
|
|
2740
|
+
/**
|
|
2741
|
+
* __useAddMessageMutation__
|
|
2742
|
+
*
|
|
2743
|
+
* To run a mutation, you first call `useAddMessageMutation` within a React component and pass it any options that fit your needs.
|
|
2744
|
+
* When your component renders, `useAddMessageMutation` returns a tuple that includes:
|
|
2745
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2746
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2747
|
+
*
|
|
2748
|
+
* @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;
|
|
2749
|
+
*
|
|
2750
|
+
* @example
|
|
2751
|
+
* const [addMessageMutation, { data, loading, error }] = useAddMessageMutation({
|
|
2752
|
+
* variables: {
|
|
2753
|
+
* input: // value for 'input'
|
|
2754
|
+
* },
|
|
2755
|
+
* });
|
|
2756
|
+
*/
|
|
2757
|
+
export declare function useAddMessageMutation(baseOptions?: Apollo.MutationHookOptions<AddMessageMutation, AddMessageMutationVariables>): Apollo.MutationTuple<AddMessageMutation, Exact<{
|
|
2758
|
+
input: MessageInput;
|
|
2759
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
2760
|
+
export type AddMessageMutationHookResult = ReturnType<typeof useAddMessageMutation>;
|
|
2761
|
+
export type AddMessageMutationResult = Apollo.MutationResult<AddMessageMutation>;
|
|
2762
|
+
export type AddMessageMutationOptions = Apollo.BaseMutationOptions<AddMessageMutation, AddMessageMutationVariables>;
|
|
2763
|
+
export declare const AgentDocument: Apollo.DocumentNode;
|
|
2764
|
+
/**
|
|
2765
|
+
* __useAgentQuery__
|
|
2766
|
+
*
|
|
2767
|
+
* To run a query within a React component, call `useAgentQuery` and pass it any options that fit your needs.
|
|
2768
|
+
* When your component renders, `useAgentQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2769
|
+
* you can use to render your UI.
|
|
2770
|
+
*
|
|
2771
|
+
* @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;
|
|
2772
|
+
*
|
|
2773
|
+
* @example
|
|
2774
|
+
* const { data, loading, error } = useAgentQuery({
|
|
2775
|
+
* variables: {
|
|
2776
|
+
* input: // value for 'input'
|
|
2777
|
+
* },
|
|
2778
|
+
* });
|
|
2779
|
+
*/
|
|
2780
|
+
export declare function useAgentQuery(baseOptions: Apollo.QueryHookOptions<AgentQuery, AgentQueryVariables> & ({
|
|
2781
|
+
variables: AgentQueryVariables;
|
|
2782
|
+
skip?: boolean;
|
|
2783
|
+
} | {
|
|
2784
|
+
skip: boolean;
|
|
2785
|
+
})): Apollo.QueryResult<AgentQuery, Exact<{
|
|
2786
|
+
input: AgentInput;
|
|
2787
|
+
}>>;
|
|
2788
|
+
export declare function useAgentLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AgentQuery, AgentQueryVariables>): Apollo.LazyQueryResultTuple<AgentQuery, Exact<{
|
|
2789
|
+
input: AgentInput;
|
|
2790
|
+
}>>;
|
|
2791
|
+
export declare function useAgentSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AgentQuery, AgentQueryVariables>): Apollo.UseSuspenseQueryResult<AgentQuery | undefined, Exact<{
|
|
2792
|
+
input: AgentInput;
|
|
2793
|
+
}>>;
|
|
2794
|
+
export type AgentQueryHookResult = ReturnType<typeof useAgentQuery>;
|
|
2795
|
+
export type AgentLazyQueryHookResult = ReturnType<typeof useAgentLazyQuery>;
|
|
2796
|
+
export type AgentSuspenseQueryHookResult = ReturnType<typeof useAgentSuspenseQuery>;
|
|
2797
|
+
export type AgentQueryResult = Apollo.QueryResult<AgentQuery, AgentQueryVariables>;
|
|
2798
|
+
export declare function refetchAgentQuery(variables: AgentQueryVariables): {
|
|
2799
|
+
query: Apollo.DocumentNode;
|
|
2800
|
+
variables: Exact<{
|
|
2801
|
+
input: AgentInput;
|
|
2802
|
+
}>;
|
|
2803
|
+
};
|
|
2804
|
+
export declare const AgentsDocument: Apollo.DocumentNode;
|
|
2805
|
+
/**
|
|
2806
|
+
* __useAgentsQuery__
|
|
2807
|
+
*
|
|
2808
|
+
* To run a query within a React component, call `useAgentsQuery` and pass it any options that fit your needs.
|
|
2809
|
+
* When your component renders, `useAgentsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2810
|
+
* you can use to render your UI.
|
|
2811
|
+
*
|
|
2812
|
+
* @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;
|
|
2813
|
+
*
|
|
2814
|
+
* @example
|
|
2815
|
+
* const { data, loading, error } = useAgentsQuery({
|
|
2816
|
+
* variables: {
|
|
2817
|
+
* input: // value for 'input'
|
|
2818
|
+
* pageInfo: // value for 'pageInfo'
|
|
2819
|
+
* },
|
|
2820
|
+
* });
|
|
2821
|
+
*/
|
|
2822
|
+
export declare function useAgentsQuery(baseOptions: Apollo.QueryHookOptions<AgentsQuery, AgentsQueryVariables> & ({
|
|
2823
|
+
variables: AgentsQueryVariables;
|
|
2824
|
+
skip?: boolean;
|
|
2825
|
+
} | {
|
|
2826
|
+
skip: boolean;
|
|
2827
|
+
})): Apollo.QueryResult<AgentsQuery, Exact<{
|
|
2828
|
+
input: AgentsInput;
|
|
2829
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2830
|
+
}>>;
|
|
2831
|
+
export declare function useAgentsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AgentsQuery, AgentsQueryVariables>): Apollo.LazyQueryResultTuple<AgentsQuery, Exact<{
|
|
2832
|
+
input: AgentsInput;
|
|
2833
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2834
|
+
}>>;
|
|
2835
|
+
export declare function useAgentsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AgentsQuery, AgentsQueryVariables>): Apollo.UseSuspenseQueryResult<AgentsQuery | undefined, Exact<{
|
|
2836
|
+
input: AgentsInput;
|
|
2837
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2838
|
+
}>>;
|
|
2839
|
+
export type AgentsQueryHookResult = ReturnType<typeof useAgentsQuery>;
|
|
2840
|
+
export type AgentsLazyQueryHookResult = ReturnType<typeof useAgentsLazyQuery>;
|
|
2841
|
+
export type AgentsSuspenseQueryHookResult = ReturnType<typeof useAgentsSuspenseQuery>;
|
|
2842
|
+
export type AgentsQueryResult = Apollo.QueryResult<AgentsQuery, AgentsQueryVariables>;
|
|
2843
|
+
export declare function refetchAgentsQuery(variables: AgentsQueryVariables): {
|
|
2844
|
+
query: Apollo.DocumentNode;
|
|
2845
|
+
variables: Exact<{
|
|
2846
|
+
input: AgentsInput;
|
|
2847
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2848
|
+
}>;
|
|
2849
|
+
};
|
|
2850
|
+
export declare const AssignConvDocument: Apollo.DocumentNode;
|
|
2851
|
+
export type AssignConvMutationFn = Apollo.MutationFunction<AssignConvMutation, AssignConvMutationVariables>;
|
|
2852
|
+
/**
|
|
2853
|
+
* __useAssignConvMutation__
|
|
2854
|
+
*
|
|
2855
|
+
* To run a mutation, you first call `useAssignConvMutation` within a React component and pass it any options that fit your needs.
|
|
2856
|
+
* When your component renders, `useAssignConvMutation` returns a tuple that includes:
|
|
2857
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
2858
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
2859
|
+
*
|
|
2860
|
+
* @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;
|
|
2861
|
+
*
|
|
2862
|
+
* @example
|
|
2863
|
+
* const [assignConvMutation, { data, loading, error }] = useAssignConvMutation({
|
|
2864
|
+
* variables: {
|
|
2865
|
+
* input: // value for 'input'
|
|
2866
|
+
* },
|
|
2867
|
+
* });
|
|
2868
|
+
*/
|
|
2869
|
+
export declare function useAssignConvMutation(baseOptions?: Apollo.MutationHookOptions<AssignConvMutation, AssignConvMutationVariables>): Apollo.MutationTuple<AssignConvMutation, Exact<{
|
|
2870
|
+
input: ConvAssignInput;
|
|
2871
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
2872
|
+
export type AssignConvMutationHookResult = ReturnType<typeof useAssignConvMutation>;
|
|
2873
|
+
export type AssignConvMutationResult = Apollo.MutationResult<AssignConvMutation>;
|
|
2874
|
+
export type AssignConvMutationOptions = Apollo.BaseMutationOptions<AssignConvMutation, AssignConvMutationVariables>;
|
|
2875
|
+
export declare const BroadcastDocument: Apollo.DocumentNode;
|
|
2876
|
+
/**
|
|
2877
|
+
* __useBroadcastQuery__
|
|
2878
|
+
*
|
|
2879
|
+
* To run a query within a React component, call `useBroadcastQuery` and pass it any options that fit your needs.
|
|
2880
|
+
* When your component renders, `useBroadcastQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2881
|
+
* you can use to render your UI.
|
|
2882
|
+
*
|
|
2883
|
+
* @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;
|
|
2884
|
+
*
|
|
2885
|
+
* @example
|
|
2886
|
+
* const { data, loading, error } = useBroadcastQuery({
|
|
2887
|
+
* variables: {
|
|
2888
|
+
* input: // value for 'input'
|
|
2889
|
+
* },
|
|
2890
|
+
* });
|
|
2891
|
+
*/
|
|
2892
|
+
export declare function useBroadcastQuery(baseOptions: Apollo.QueryHookOptions<BroadcastQuery, BroadcastQueryVariables> & ({
|
|
2893
|
+
variables: BroadcastQueryVariables;
|
|
2894
|
+
skip?: boolean;
|
|
2895
|
+
} | {
|
|
2896
|
+
skip: boolean;
|
|
2897
|
+
})): Apollo.QueryResult<BroadcastQuery, Exact<{
|
|
2898
|
+
input: BroadcastInput;
|
|
2899
|
+
}>>;
|
|
2900
|
+
export declare function useBroadcastLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BroadcastQuery, BroadcastQueryVariables>): Apollo.LazyQueryResultTuple<BroadcastQuery, Exact<{
|
|
2901
|
+
input: BroadcastInput;
|
|
2902
|
+
}>>;
|
|
2903
|
+
export declare function useBroadcastSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BroadcastQuery, BroadcastQueryVariables>): Apollo.UseSuspenseQueryResult<BroadcastQuery | undefined, Exact<{
|
|
2904
|
+
input: BroadcastInput;
|
|
2905
|
+
}>>;
|
|
2906
|
+
export type BroadcastQueryHookResult = ReturnType<typeof useBroadcastQuery>;
|
|
2907
|
+
export type BroadcastLazyQueryHookResult = ReturnType<typeof useBroadcastLazyQuery>;
|
|
2908
|
+
export type BroadcastSuspenseQueryHookResult = ReturnType<typeof useBroadcastSuspenseQuery>;
|
|
2909
|
+
export type BroadcastQueryResult = Apollo.QueryResult<BroadcastQuery, BroadcastQueryVariables>;
|
|
2910
|
+
export declare function refetchBroadcastQuery(variables: BroadcastQueryVariables): {
|
|
2911
|
+
query: Apollo.DocumentNode;
|
|
2912
|
+
variables: Exact<{
|
|
2913
|
+
input: BroadcastInput;
|
|
2914
|
+
}>;
|
|
2915
|
+
};
|
|
2916
|
+
export declare const BroadcastsDocument: Apollo.DocumentNode;
|
|
2917
|
+
/**
|
|
2918
|
+
* __useBroadcastsQuery__
|
|
2919
|
+
*
|
|
2920
|
+
* To run a query within a React component, call `useBroadcastsQuery` and pass it any options that fit your needs.
|
|
2921
|
+
* When your component renders, `useBroadcastsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2922
|
+
* you can use to render your UI.
|
|
2923
|
+
*
|
|
2924
|
+
* @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;
|
|
2925
|
+
*
|
|
2926
|
+
* @example
|
|
2927
|
+
* const { data, loading, error } = useBroadcastsQuery({
|
|
2928
|
+
* variables: {
|
|
2929
|
+
* input: // value for 'input'
|
|
2930
|
+
* pageInfo: // value for 'pageInfo'
|
|
2931
|
+
* },
|
|
2932
|
+
* });
|
|
2933
|
+
*/
|
|
2934
|
+
export declare function useBroadcastsQuery(baseOptions: Apollo.QueryHookOptions<BroadcastsQuery, BroadcastsQueryVariables> & ({
|
|
2935
|
+
variables: BroadcastsQueryVariables;
|
|
2936
|
+
skip?: boolean;
|
|
2937
|
+
} | {
|
|
2938
|
+
skip: boolean;
|
|
2939
|
+
})): Apollo.QueryResult<BroadcastsQuery, Exact<{
|
|
2940
|
+
input: BroadcastsInput;
|
|
2941
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2942
|
+
}>>;
|
|
2943
|
+
export declare function useBroadcastsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BroadcastsQuery, BroadcastsQueryVariables>): Apollo.LazyQueryResultTuple<BroadcastsQuery, Exact<{
|
|
2944
|
+
input: BroadcastsInput;
|
|
2945
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2946
|
+
}>>;
|
|
2947
|
+
export declare function useBroadcastsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BroadcastsQuery, BroadcastsQueryVariables>): Apollo.UseSuspenseQueryResult<BroadcastsQuery | undefined, Exact<{
|
|
2948
|
+
input: BroadcastsInput;
|
|
2949
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2950
|
+
}>>;
|
|
2951
|
+
export type BroadcastsQueryHookResult = ReturnType<typeof useBroadcastsQuery>;
|
|
2952
|
+
export type BroadcastsLazyQueryHookResult = ReturnType<typeof useBroadcastsLazyQuery>;
|
|
2953
|
+
export type BroadcastsSuspenseQueryHookResult = ReturnType<typeof useBroadcastsSuspenseQuery>;
|
|
2954
|
+
export type BroadcastsQueryResult = Apollo.QueryResult<BroadcastsQuery, BroadcastsQueryVariables>;
|
|
2955
|
+
export declare function refetchBroadcastsQuery(variables: BroadcastsQueryVariables): {
|
|
2956
|
+
query: Apollo.DocumentNode;
|
|
2957
|
+
variables: Exact<{
|
|
2958
|
+
input: BroadcastsInput;
|
|
2959
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
2960
|
+
}>;
|
|
2961
|
+
};
|
|
2962
|
+
export declare const ClientDocument: Apollo.DocumentNode;
|
|
2963
|
+
/**
|
|
2964
|
+
* __useClientQuery__
|
|
2965
|
+
*
|
|
2966
|
+
* To run a query within a React component, call `useClientQuery` and pass it any options that fit your needs.
|
|
2967
|
+
* When your component renders, `useClientQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
2968
|
+
* you can use to render your UI.
|
|
2969
|
+
*
|
|
2970
|
+
* @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;
|
|
2971
|
+
*
|
|
2972
|
+
* @example
|
|
2973
|
+
* const { data, loading, error } = useClientQuery({
|
|
2974
|
+
* variables: {
|
|
2975
|
+
* input: // value for 'input'
|
|
2976
|
+
* },
|
|
2977
|
+
* });
|
|
2978
|
+
*/
|
|
2979
|
+
export declare function useClientQuery(baseOptions: Apollo.QueryHookOptions<ClientQuery, ClientQueryVariables> & ({
|
|
2980
|
+
variables: ClientQueryVariables;
|
|
2981
|
+
skip?: boolean;
|
|
2982
|
+
} | {
|
|
2983
|
+
skip: boolean;
|
|
2984
|
+
})): Apollo.QueryResult<ClientQuery, Exact<{
|
|
2985
|
+
input: ClientInput;
|
|
2986
|
+
}>>;
|
|
2987
|
+
export declare function useClientLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientQuery, ClientQueryVariables>): Apollo.LazyQueryResultTuple<ClientQuery, Exact<{
|
|
2988
|
+
input: ClientInput;
|
|
2989
|
+
}>>;
|
|
2990
|
+
export declare function useClientSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientQuery, ClientQueryVariables>): Apollo.UseSuspenseQueryResult<ClientQuery | undefined, Exact<{
|
|
2991
|
+
input: ClientInput;
|
|
2992
|
+
}>>;
|
|
2993
|
+
export type ClientQueryHookResult = ReturnType<typeof useClientQuery>;
|
|
2994
|
+
export type ClientLazyQueryHookResult = ReturnType<typeof useClientLazyQuery>;
|
|
2995
|
+
export type ClientSuspenseQueryHookResult = ReturnType<typeof useClientSuspenseQuery>;
|
|
2996
|
+
export type ClientQueryResult = Apollo.QueryResult<ClientQuery, ClientQueryVariables>;
|
|
2997
|
+
export declare function refetchClientQuery(variables: ClientQueryVariables): {
|
|
2998
|
+
query: Apollo.DocumentNode;
|
|
2999
|
+
variables: Exact<{
|
|
3000
|
+
input: ClientInput;
|
|
3001
|
+
}>;
|
|
3002
|
+
};
|
|
3003
|
+
export declare const ClientsDocument: Apollo.DocumentNode;
|
|
3004
|
+
/**
|
|
3005
|
+
* __useClientsQuery__
|
|
3006
|
+
*
|
|
3007
|
+
* To run a query within a React component, call `useClientsQuery` and pass it any options that fit your needs.
|
|
3008
|
+
* When your component renders, `useClientsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3009
|
+
* you can use to render your UI.
|
|
3010
|
+
*
|
|
3011
|
+
* @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;
|
|
3012
|
+
*
|
|
3013
|
+
* @example
|
|
3014
|
+
* const { data, loading, error } = useClientsQuery({
|
|
3015
|
+
* variables: {
|
|
3016
|
+
* input: // value for 'input'
|
|
3017
|
+
* pageInfo: // value for 'pageInfo'
|
|
3018
|
+
* },
|
|
3019
|
+
* });
|
|
3020
|
+
*/
|
|
3021
|
+
export declare function useClientsQuery(baseOptions: Apollo.QueryHookOptions<ClientsQuery, ClientsQueryVariables> & ({
|
|
3022
|
+
variables: ClientsQueryVariables;
|
|
3023
|
+
skip?: boolean;
|
|
3024
|
+
} | {
|
|
3025
|
+
skip: boolean;
|
|
3026
|
+
})): Apollo.QueryResult<ClientsQuery, Exact<{
|
|
3027
|
+
input: ClientsInput;
|
|
3028
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3029
|
+
}>>;
|
|
3030
|
+
export declare function useClientsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientsQuery, ClientsQueryVariables>): Apollo.LazyQueryResultTuple<ClientsQuery, Exact<{
|
|
3031
|
+
input: ClientsInput;
|
|
3032
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3033
|
+
}>>;
|
|
3034
|
+
export declare function useClientsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientsQuery, ClientsQueryVariables>): Apollo.UseSuspenseQueryResult<ClientsQuery | undefined, Exact<{
|
|
3035
|
+
input: ClientsInput;
|
|
3036
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3037
|
+
}>>;
|
|
3038
|
+
export type ClientsQueryHookResult = ReturnType<typeof useClientsQuery>;
|
|
3039
|
+
export type ClientsLazyQueryHookResult = ReturnType<typeof useClientsLazyQuery>;
|
|
3040
|
+
export type ClientsSuspenseQueryHookResult = ReturnType<typeof useClientsSuspenseQuery>;
|
|
3041
|
+
export type ClientsQueryResult = Apollo.QueryResult<ClientsQuery, ClientsQueryVariables>;
|
|
3042
|
+
export declare function refetchClientsQuery(variables: ClientsQueryVariables): {
|
|
3043
|
+
query: Apollo.DocumentNode;
|
|
3044
|
+
variables: Exact<{
|
|
3045
|
+
input: ClientsInput;
|
|
3046
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3047
|
+
}>;
|
|
3048
|
+
};
|
|
3049
|
+
export declare const ConvsDocument: Apollo.DocumentNode;
|
|
3050
|
+
/**
|
|
3051
|
+
* __useConvsQuery__
|
|
3052
|
+
*
|
|
3053
|
+
* To run a query within a React component, call `useConvsQuery` and pass it any options that fit your needs.
|
|
3054
|
+
* When your component renders, `useConvsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3055
|
+
* you can use to render your UI.
|
|
3056
|
+
*
|
|
3057
|
+
* @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;
|
|
3058
|
+
*
|
|
3059
|
+
* @example
|
|
3060
|
+
* const { data, loading, error } = useConvsQuery({
|
|
3061
|
+
* variables: {
|
|
3062
|
+
* input: // value for 'input'
|
|
3063
|
+
* pageInfo: // value for 'pageInfo'
|
|
3064
|
+
* },
|
|
3065
|
+
* });
|
|
3066
|
+
*/
|
|
3067
|
+
export declare function useConvsQuery(baseOptions: Apollo.QueryHookOptions<ConvsQuery, ConvsQueryVariables> & ({
|
|
3068
|
+
variables: ConvsQueryVariables;
|
|
3069
|
+
skip?: boolean;
|
|
3070
|
+
} | {
|
|
3071
|
+
skip: boolean;
|
|
3072
|
+
})): Apollo.QueryResult<ConvsQuery, Exact<{
|
|
3073
|
+
input: ConvsInput;
|
|
3074
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3075
|
+
}>>;
|
|
3076
|
+
export declare function useConvsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ConvsQuery, ConvsQueryVariables>): Apollo.LazyQueryResultTuple<ConvsQuery, Exact<{
|
|
3077
|
+
input: ConvsInput;
|
|
3078
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3079
|
+
}>>;
|
|
3080
|
+
export declare function useConvsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ConvsQuery, ConvsQueryVariables>): Apollo.UseSuspenseQueryResult<ConvsQuery | undefined, Exact<{
|
|
3081
|
+
input: ConvsInput;
|
|
3082
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3083
|
+
}>>;
|
|
3084
|
+
export type ConvsQueryHookResult = ReturnType<typeof useConvsQuery>;
|
|
3085
|
+
export type ConvsLazyQueryHookResult = ReturnType<typeof useConvsLazyQuery>;
|
|
3086
|
+
export type ConvsSuspenseQueryHookResult = ReturnType<typeof useConvsSuspenseQuery>;
|
|
3087
|
+
export type ConvsQueryResult = Apollo.QueryResult<ConvsQuery, ConvsQueryVariables>;
|
|
3088
|
+
export declare function refetchConvsQuery(variables: ConvsQueryVariables): {
|
|
3089
|
+
query: Apollo.DocumentNode;
|
|
3090
|
+
variables: Exact<{
|
|
3091
|
+
input: ConvsInput;
|
|
3092
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3093
|
+
}>;
|
|
3094
|
+
};
|
|
3095
|
+
export declare const CreateAgentDocument: Apollo.DocumentNode;
|
|
3096
|
+
export type CreateAgentMutationFn = Apollo.MutationFunction<CreateAgentMutation, CreateAgentMutationVariables>;
|
|
3097
|
+
/**
|
|
3098
|
+
* __useCreateAgentMutation__
|
|
3099
|
+
*
|
|
3100
|
+
* To run a mutation, you first call `useCreateAgentMutation` within a React component and pass it any options that fit your needs.
|
|
3101
|
+
* When your component renders, `useCreateAgentMutation` returns a tuple that includes:
|
|
3102
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3103
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3104
|
+
*
|
|
3105
|
+
* @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;
|
|
3106
|
+
*
|
|
3107
|
+
* @example
|
|
3108
|
+
* const [createAgentMutation, { data, loading, error }] = useCreateAgentMutation({
|
|
3109
|
+
* variables: {
|
|
3110
|
+
* input: // value for 'input'
|
|
3111
|
+
* },
|
|
3112
|
+
* });
|
|
3113
|
+
*/
|
|
3114
|
+
export declare function useCreateAgentMutation(baseOptions?: Apollo.MutationHookOptions<CreateAgentMutation, CreateAgentMutationVariables>): Apollo.MutationTuple<CreateAgentMutation, Exact<{
|
|
3115
|
+
input: AgentCreateInput;
|
|
3116
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3117
|
+
export type CreateAgentMutationHookResult = ReturnType<typeof useCreateAgentMutation>;
|
|
3118
|
+
export type CreateAgentMutationResult = Apollo.MutationResult<CreateAgentMutation>;
|
|
3119
|
+
export type CreateAgentMutationOptions = Apollo.BaseMutationOptions<CreateAgentMutation, CreateAgentMutationVariables>;
|
|
3120
|
+
export declare const CreateBroadcastDocument: Apollo.DocumentNode;
|
|
3121
|
+
export type CreateBroadcastMutationFn = Apollo.MutationFunction<CreateBroadcastMutation, CreateBroadcastMutationVariables>;
|
|
3122
|
+
/**
|
|
3123
|
+
* __useCreateBroadcastMutation__
|
|
3124
|
+
*
|
|
3125
|
+
* To run a mutation, you first call `useCreateBroadcastMutation` within a React component and pass it any options that fit your needs.
|
|
3126
|
+
* When your component renders, `useCreateBroadcastMutation` returns a tuple that includes:
|
|
3127
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3128
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3129
|
+
*
|
|
3130
|
+
* @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;
|
|
3131
|
+
*
|
|
3132
|
+
* @example
|
|
3133
|
+
* const [createBroadcastMutation, { data, loading, error }] = useCreateBroadcastMutation({
|
|
3134
|
+
* variables: {
|
|
3135
|
+
* input: // value for 'input'
|
|
3136
|
+
* },
|
|
3137
|
+
* });
|
|
3138
|
+
*/
|
|
3139
|
+
export declare function useCreateBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<CreateBroadcastMutation, CreateBroadcastMutationVariables>): Apollo.MutationTuple<CreateBroadcastMutation, Exact<{
|
|
3140
|
+
input: BroadcastCreateInput;
|
|
3141
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3142
|
+
export type CreateBroadcastMutationHookResult = ReturnType<typeof useCreateBroadcastMutation>;
|
|
3143
|
+
export type CreateBroadcastMutationResult = Apollo.MutationResult<CreateBroadcastMutation>;
|
|
3144
|
+
export type CreateBroadcastMutationOptions = Apollo.BaseMutationOptions<CreateBroadcastMutation, CreateBroadcastMutationVariables>;
|
|
3145
|
+
export declare const DeleteAgentDocument: Apollo.DocumentNode;
|
|
3146
|
+
export type DeleteAgentMutationFn = Apollo.MutationFunction<DeleteAgentMutation, DeleteAgentMutationVariables>;
|
|
3147
|
+
/**
|
|
3148
|
+
* __useDeleteAgentMutation__
|
|
3149
|
+
*
|
|
3150
|
+
* To run a mutation, you first call `useDeleteAgentMutation` within a React component and pass it any options that fit your needs.
|
|
3151
|
+
* When your component renders, `useDeleteAgentMutation` returns a tuple that includes:
|
|
3152
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3153
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3154
|
+
*
|
|
3155
|
+
* @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;
|
|
3156
|
+
*
|
|
3157
|
+
* @example
|
|
3158
|
+
* const [deleteAgentMutation, { data, loading, error }] = useDeleteAgentMutation({
|
|
3159
|
+
* variables: {
|
|
3160
|
+
* input: // value for 'input'
|
|
3161
|
+
* },
|
|
3162
|
+
* });
|
|
3163
|
+
*/
|
|
3164
|
+
export declare function useDeleteAgentMutation(baseOptions?: Apollo.MutationHookOptions<DeleteAgentMutation, DeleteAgentMutationVariables>): Apollo.MutationTuple<DeleteAgentMutation, Exact<{
|
|
3165
|
+
input: AgentInput;
|
|
3166
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3167
|
+
export type DeleteAgentMutationHookResult = ReturnType<typeof useDeleteAgentMutation>;
|
|
3168
|
+
export type DeleteAgentMutationResult = Apollo.MutationResult<DeleteAgentMutation>;
|
|
3169
|
+
export type DeleteAgentMutationOptions = Apollo.BaseMutationOptions<DeleteAgentMutation, DeleteAgentMutationVariables>;
|
|
3170
|
+
export declare const DeleteBroadcastDocument: Apollo.DocumentNode;
|
|
3171
|
+
export type DeleteBroadcastMutationFn = Apollo.MutationFunction<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>;
|
|
3172
|
+
/**
|
|
3173
|
+
* __useDeleteBroadcastMutation__
|
|
3174
|
+
*
|
|
3175
|
+
* To run a mutation, you first call `useDeleteBroadcastMutation` within a React component and pass it any options that fit your needs.
|
|
3176
|
+
* When your component renders, `useDeleteBroadcastMutation` returns a tuple that includes:
|
|
3177
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3178
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3179
|
+
*
|
|
3180
|
+
* @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;
|
|
3181
|
+
*
|
|
3182
|
+
* @example
|
|
3183
|
+
* const [deleteBroadcastMutation, { data, loading, error }] = useDeleteBroadcastMutation({
|
|
3184
|
+
* variables: {
|
|
3185
|
+
* input: // value for 'input'
|
|
3186
|
+
* },
|
|
3187
|
+
* });
|
|
3188
|
+
*/
|
|
3189
|
+
export declare function useDeleteBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>): Apollo.MutationTuple<DeleteBroadcastMutation, Exact<{
|
|
3190
|
+
input: BroadcastDeleteInput;
|
|
3191
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3192
|
+
export type DeleteBroadcastMutationHookResult = ReturnType<typeof useDeleteBroadcastMutation>;
|
|
3193
|
+
export type DeleteBroadcastMutationResult = Apollo.MutationResult<DeleteBroadcastMutation>;
|
|
3194
|
+
export type DeleteBroadcastMutationOptions = Apollo.BaseMutationOptions<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>;
|
|
3195
|
+
export declare const EndConvDocument: Apollo.DocumentNode;
|
|
3196
|
+
export type EndConvMutationFn = Apollo.MutationFunction<EndConvMutation, EndConvMutationVariables>;
|
|
3197
|
+
/**
|
|
3198
|
+
* __useEndConvMutation__
|
|
3199
|
+
*
|
|
3200
|
+
* To run a mutation, you first call `useEndConvMutation` within a React component and pass it any options that fit your needs.
|
|
3201
|
+
* When your component renders, `useEndConvMutation` returns a tuple that includes:
|
|
3202
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3203
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3204
|
+
*
|
|
3205
|
+
* @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;
|
|
3206
|
+
*
|
|
3207
|
+
* @example
|
|
3208
|
+
* const [endConvMutation, { data, loading, error }] = useEndConvMutation({
|
|
3209
|
+
* variables: {
|
|
3210
|
+
* input: // value for 'input'
|
|
3211
|
+
* },
|
|
3212
|
+
* });
|
|
3213
|
+
*/
|
|
3214
|
+
export declare function useEndConvMutation(baseOptions?: Apollo.MutationHookOptions<EndConvMutation, EndConvMutationVariables>): Apollo.MutationTuple<EndConvMutation, Exact<{
|
|
3215
|
+
input: ConvEndInput;
|
|
3216
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3217
|
+
export type EndConvMutationHookResult = ReturnType<typeof useEndConvMutation>;
|
|
3218
|
+
export type EndConvMutationResult = Apollo.MutationResult<EndConvMutation>;
|
|
3219
|
+
export type EndConvMutationOptions = Apollo.BaseMutationOptions<EndConvMutation, EndConvMutationVariables>;
|
|
3220
|
+
export declare const LaunchBroadcastDocument: Apollo.DocumentNode;
|
|
3221
|
+
export type LaunchBroadcastMutationFn = Apollo.MutationFunction<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>;
|
|
3222
|
+
/**
|
|
3223
|
+
* __useLaunchBroadcastMutation__
|
|
3224
|
+
*
|
|
3225
|
+
* To run a mutation, you first call `useLaunchBroadcastMutation` within a React component and pass it any options that fit your needs.
|
|
3226
|
+
* When your component renders, `useLaunchBroadcastMutation` returns a tuple that includes:
|
|
3227
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3228
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3229
|
+
*
|
|
3230
|
+
* @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;
|
|
3231
|
+
*
|
|
3232
|
+
* @example
|
|
3233
|
+
* const [launchBroadcastMutation, { data, loading, error }] = useLaunchBroadcastMutation({
|
|
3234
|
+
* variables: {
|
|
3235
|
+
* input: // value for 'input'
|
|
3236
|
+
* },
|
|
3237
|
+
* });
|
|
3238
|
+
*/
|
|
3239
|
+
export declare function useLaunchBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>): Apollo.MutationTuple<LaunchBroadcastMutation, Exact<{
|
|
3240
|
+
input: BroadcastLaunchInput;
|
|
3241
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3242
|
+
export type LaunchBroadcastMutationHookResult = ReturnType<typeof useLaunchBroadcastMutation>;
|
|
3243
|
+
export type LaunchBroadcastMutationResult = Apollo.MutationResult<LaunchBroadcastMutation>;
|
|
3244
|
+
export type LaunchBroadcastMutationOptions = Apollo.BaseMutationOptions<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>;
|
|
3245
|
+
export declare const MessagesDocument: Apollo.DocumentNode;
|
|
3246
|
+
/**
|
|
3247
|
+
* __useMessagesQuery__
|
|
3248
|
+
*
|
|
3249
|
+
* To run a query within a React component, call `useMessagesQuery` and pass it any options that fit your needs.
|
|
3250
|
+
* When your component renders, `useMessagesQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3251
|
+
* you can use to render your UI.
|
|
3252
|
+
*
|
|
3253
|
+
* @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;
|
|
3254
|
+
*
|
|
3255
|
+
* @example
|
|
3256
|
+
* const { data, loading, error } = useMessagesQuery({
|
|
3257
|
+
* variables: {
|
|
3258
|
+
* input: // value for 'input'
|
|
3259
|
+
* pageInfo: // value for 'pageInfo'
|
|
3260
|
+
* },
|
|
3261
|
+
* });
|
|
3262
|
+
*/
|
|
3263
|
+
export declare function useMessagesQuery(baseOptions: Apollo.QueryHookOptions<MessagesQuery, MessagesQueryVariables> & ({
|
|
3264
|
+
variables: MessagesQueryVariables;
|
|
3265
|
+
skip?: boolean;
|
|
3266
|
+
} | {
|
|
3267
|
+
skip: boolean;
|
|
3268
|
+
})): Apollo.QueryResult<MessagesQuery, Exact<{
|
|
3269
|
+
input: MessagesInput;
|
|
3270
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3271
|
+
}>>;
|
|
3272
|
+
export declare function useMessagesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MessagesQuery, MessagesQueryVariables>): Apollo.LazyQueryResultTuple<MessagesQuery, Exact<{
|
|
3273
|
+
input: MessagesInput;
|
|
3274
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3275
|
+
}>>;
|
|
3276
|
+
export declare function useMessagesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<MessagesQuery, MessagesQueryVariables>): Apollo.UseSuspenseQueryResult<MessagesQuery | undefined, Exact<{
|
|
3277
|
+
input: MessagesInput;
|
|
3278
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3279
|
+
}>>;
|
|
3280
|
+
export type MessagesQueryHookResult = ReturnType<typeof useMessagesQuery>;
|
|
3281
|
+
export type MessagesLazyQueryHookResult = ReturnType<typeof useMessagesLazyQuery>;
|
|
3282
|
+
export type MessagesSuspenseQueryHookResult = ReturnType<typeof useMessagesSuspenseQuery>;
|
|
3283
|
+
export type MessagesQueryResult = Apollo.QueryResult<MessagesQuery, MessagesQueryVariables>;
|
|
3284
|
+
export declare function refetchMessagesQuery(variables: MessagesQueryVariables): {
|
|
3285
|
+
query: Apollo.DocumentNode;
|
|
3286
|
+
variables: Exact<{
|
|
3287
|
+
input: MessagesInput;
|
|
3288
|
+
pageInfo?: InputMaybe<PageInfoInput> | undefined;
|
|
3289
|
+
}>;
|
|
3290
|
+
};
|
|
3291
|
+
export declare const PatchAgentDocument: Apollo.DocumentNode;
|
|
3292
|
+
export type PatchAgentMutationFn = Apollo.MutationFunction<PatchAgentMutation, PatchAgentMutationVariables>;
|
|
3293
|
+
/**
|
|
3294
|
+
* __usePatchAgentMutation__
|
|
3295
|
+
*
|
|
3296
|
+
* To run a mutation, you first call `usePatchAgentMutation` within a React component and pass it any options that fit your needs.
|
|
3297
|
+
* When your component renders, `usePatchAgentMutation` returns a tuple that includes:
|
|
3298
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3299
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3300
|
+
*
|
|
3301
|
+
* @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;
|
|
3302
|
+
*
|
|
3303
|
+
* @example
|
|
3304
|
+
* const [patchAgentMutation, { data, loading, error }] = usePatchAgentMutation({
|
|
3305
|
+
* variables: {
|
|
3306
|
+
* input: // value for 'input'
|
|
3307
|
+
* },
|
|
3308
|
+
* });
|
|
3309
|
+
*/
|
|
3310
|
+
export declare function usePatchAgentMutation(baseOptions?: Apollo.MutationHookOptions<PatchAgentMutation, PatchAgentMutationVariables>): Apollo.MutationTuple<PatchAgentMutation, Exact<{
|
|
3311
|
+
input: AgentPatchInput;
|
|
3312
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3313
|
+
export type PatchAgentMutationHookResult = ReturnType<typeof usePatchAgentMutation>;
|
|
3314
|
+
export type PatchAgentMutationResult = Apollo.MutationResult<PatchAgentMutation>;
|
|
3315
|
+
export type PatchAgentMutationOptions = Apollo.BaseMutationOptions<PatchAgentMutation, PatchAgentMutationVariables>;
|
|
3316
|
+
export declare const PatchBroadcastDocument: Apollo.DocumentNode;
|
|
3317
|
+
export type PatchBroadcastMutationFn = Apollo.MutationFunction<PatchBroadcastMutation, PatchBroadcastMutationVariables>;
|
|
3318
|
+
/**
|
|
3319
|
+
* __usePatchBroadcastMutation__
|
|
3320
|
+
*
|
|
3321
|
+
* To run a mutation, you first call `usePatchBroadcastMutation` within a React component and pass it any options that fit your needs.
|
|
3322
|
+
* When your component renders, `usePatchBroadcastMutation` returns a tuple that includes:
|
|
3323
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3324
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3325
|
+
*
|
|
3326
|
+
* @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;
|
|
3327
|
+
*
|
|
3328
|
+
* @example
|
|
3329
|
+
* const [patchBroadcastMutation, { data, loading, error }] = usePatchBroadcastMutation({
|
|
3330
|
+
* variables: {
|
|
3331
|
+
* input: // value for 'input'
|
|
3332
|
+
* },
|
|
3333
|
+
* });
|
|
3334
|
+
*/
|
|
3335
|
+
export declare function usePatchBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<PatchBroadcastMutation, PatchBroadcastMutationVariables>): Apollo.MutationTuple<PatchBroadcastMutation, Exact<{
|
|
3336
|
+
input: BroadcastPatchInput;
|
|
3337
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3338
|
+
export type PatchBroadcastMutationHookResult = ReturnType<typeof usePatchBroadcastMutation>;
|
|
3339
|
+
export type PatchBroadcastMutationResult = Apollo.MutationResult<PatchBroadcastMutation>;
|
|
3340
|
+
export type PatchBroadcastMutationOptions = Apollo.BaseMutationOptions<PatchBroadcastMutation, PatchBroadcastMutationVariables>;
|
|
3341
|
+
export declare const PatchClientDocument: Apollo.DocumentNode;
|
|
3342
|
+
export type PatchClientMutationFn = Apollo.MutationFunction<PatchClientMutation, PatchClientMutationVariables>;
|
|
3343
|
+
/**
|
|
3344
|
+
* __usePatchClientMutation__
|
|
3345
|
+
*
|
|
3346
|
+
* To run a mutation, you first call `usePatchClientMutation` within a React component and pass it any options that fit your needs.
|
|
3347
|
+
* When your component renders, `usePatchClientMutation` returns a tuple that includes:
|
|
3348
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3349
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3350
|
+
*
|
|
3351
|
+
* @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;
|
|
3352
|
+
*
|
|
3353
|
+
* @example
|
|
3354
|
+
* const [patchClientMutation, { data, loading, error }] = usePatchClientMutation({
|
|
3355
|
+
* variables: {
|
|
3356
|
+
* input: // value for 'input'
|
|
3357
|
+
* },
|
|
3358
|
+
* });
|
|
3359
|
+
*/
|
|
3360
|
+
export declare function usePatchClientMutation(baseOptions?: Apollo.MutationHookOptions<PatchClientMutation, PatchClientMutationVariables>): Apollo.MutationTuple<PatchClientMutation, Exact<{
|
|
3361
|
+
input: ClientPatchInput;
|
|
3362
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3363
|
+
export type PatchClientMutationHookResult = ReturnType<typeof usePatchClientMutation>;
|
|
3364
|
+
export type PatchClientMutationResult = Apollo.MutationResult<PatchClientMutation>;
|
|
3365
|
+
export type PatchClientMutationOptions = Apollo.BaseMutationOptions<PatchClientMutation, PatchClientMutationVariables>;
|
|
3366
|
+
export declare const PatchConvDocument: Apollo.DocumentNode;
|
|
3367
|
+
export type PatchConvMutationFn = Apollo.MutationFunction<PatchConvMutation, PatchConvMutationVariables>;
|
|
3368
|
+
/**
|
|
3369
|
+
* __usePatchConvMutation__
|
|
3370
|
+
*
|
|
3371
|
+
* To run a mutation, you first call `usePatchConvMutation` within a React component and pass it any options that fit your needs.
|
|
3372
|
+
* When your component renders, `usePatchConvMutation` returns a tuple that includes:
|
|
3373
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3374
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3375
|
+
*
|
|
3376
|
+
* @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;
|
|
3377
|
+
*
|
|
3378
|
+
* @example
|
|
3379
|
+
* const [patchConvMutation, { data, loading, error }] = usePatchConvMutation({
|
|
3380
|
+
* variables: {
|
|
3381
|
+
* input: // value for 'input'
|
|
3382
|
+
* },
|
|
3383
|
+
* });
|
|
3384
|
+
*/
|
|
3385
|
+
export declare function usePatchConvMutation(baseOptions?: Apollo.MutationHookOptions<PatchConvMutation, PatchConvMutationVariables>): Apollo.MutationTuple<PatchConvMutation, Exact<{
|
|
3386
|
+
input: ConvPatchInput;
|
|
3387
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3388
|
+
export type PatchConvMutationHookResult = ReturnType<typeof usePatchConvMutation>;
|
|
3389
|
+
export type PatchConvMutationResult = Apollo.MutationResult<PatchConvMutation>;
|
|
3390
|
+
export type PatchConvMutationOptions = Apollo.BaseMutationOptions<PatchConvMutation, PatchConvMutationVariables>;
|
|
3391
|
+
export declare const StartConvDocument: Apollo.DocumentNode;
|
|
3392
|
+
export type StartConvMutationFn = Apollo.MutationFunction<StartConvMutation, StartConvMutationVariables>;
|
|
3393
|
+
/**
|
|
3394
|
+
* __useStartConvMutation__
|
|
3395
|
+
*
|
|
3396
|
+
* To run a mutation, you first call `useStartConvMutation` within a React component and pass it any options that fit your needs.
|
|
3397
|
+
* When your component renders, `useStartConvMutation` returns a tuple that includes:
|
|
3398
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3399
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3400
|
+
*
|
|
3401
|
+
* @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;
|
|
3402
|
+
*
|
|
3403
|
+
* @example
|
|
3404
|
+
* const [startConvMutation, { data, loading, error }] = useStartConvMutation({
|
|
3405
|
+
* variables: {
|
|
3406
|
+
* input: // value for 'input'
|
|
3407
|
+
* },
|
|
3408
|
+
* });
|
|
3409
|
+
*/
|
|
3410
|
+
export declare function useStartConvMutation(baseOptions?: Apollo.MutationHookOptions<StartConvMutation, StartConvMutationVariables>): Apollo.MutationTuple<StartConvMutation, Exact<{
|
|
3411
|
+
input: ConvStartInput;
|
|
3412
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3413
|
+
export type StartConvMutationHookResult = ReturnType<typeof useStartConvMutation>;
|
|
3414
|
+
export type StartConvMutationResult = Apollo.MutationResult<StartConvMutation>;
|
|
3415
|
+
export type StartConvMutationOptions = Apollo.BaseMutationOptions<StartConvMutation, StartConvMutationVariables>;
|
|
3416
|
+
export declare const TagClientDocument: Apollo.DocumentNode;
|
|
3417
|
+
export type TagClientMutationFn = Apollo.MutationFunction<TagClientMutation, TagClientMutationVariables>;
|
|
3418
|
+
/**
|
|
3419
|
+
* __useTagClientMutation__
|
|
3420
|
+
*
|
|
3421
|
+
* To run a mutation, you first call `useTagClientMutation` within a React component and pass it any options that fit your needs.
|
|
3422
|
+
* When your component renders, `useTagClientMutation` returns a tuple that includes:
|
|
3423
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3424
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3425
|
+
*
|
|
3426
|
+
* @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;
|
|
3427
|
+
*
|
|
3428
|
+
* @example
|
|
3429
|
+
* const [tagClientMutation, { data, loading, error }] = useTagClientMutation({
|
|
3430
|
+
* variables: {
|
|
3431
|
+
* input: // value for 'input'
|
|
3432
|
+
* },
|
|
3433
|
+
* });
|
|
3434
|
+
*/
|
|
3435
|
+
export declare function useTagClientMutation(baseOptions?: Apollo.MutationHookOptions<TagClientMutation, TagClientMutationVariables>): Apollo.MutationTuple<TagClientMutation, Exact<{
|
|
3436
|
+
input: ClientTagInput;
|
|
3437
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3438
|
+
export type TagClientMutationHookResult = ReturnType<typeof useTagClientMutation>;
|
|
3439
|
+
export type TagClientMutationResult = Apollo.MutationResult<TagClientMutation>;
|
|
3440
|
+
export type TagClientMutationOptions = Apollo.BaseMutationOptions<TagClientMutation, TagClientMutationVariables>;
|
|
3441
|
+
export declare const TagConvDocument: Apollo.DocumentNode;
|
|
3442
|
+
export type TagConvMutationFn = Apollo.MutationFunction<TagConvMutation, TagConvMutationVariables>;
|
|
3443
|
+
/**
|
|
3444
|
+
* __useTagConvMutation__
|
|
3445
|
+
*
|
|
3446
|
+
* To run a mutation, you first call `useTagConvMutation` within a React component and pass it any options that fit your needs.
|
|
3447
|
+
* When your component renders, `useTagConvMutation` returns a tuple that includes:
|
|
3448
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3449
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3450
|
+
*
|
|
3451
|
+
* @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;
|
|
3452
|
+
*
|
|
3453
|
+
* @example
|
|
3454
|
+
* const [tagConvMutation, { data, loading, error }] = useTagConvMutation({
|
|
3455
|
+
* variables: {
|
|
3456
|
+
* input: // value for 'input'
|
|
3457
|
+
* },
|
|
3458
|
+
* });
|
|
3459
|
+
*/
|
|
3460
|
+
export declare function useTagConvMutation(baseOptions?: Apollo.MutationHookOptions<TagConvMutation, TagConvMutationVariables>): Apollo.MutationTuple<TagConvMutation, Exact<{
|
|
3461
|
+
input: ConvTagInput;
|
|
3462
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3463
|
+
export type TagConvMutationHookResult = ReturnType<typeof useTagConvMutation>;
|
|
3464
|
+
export type TagConvMutationResult = Apollo.MutationResult<TagConvMutation>;
|
|
3465
|
+
export type TagConvMutationOptions = Apollo.BaseMutationOptions<TagConvMutation, TagConvMutationVariables>;
|
|
3466
|
+
export declare const TagsDocument: Apollo.DocumentNode;
|
|
3467
|
+
/**
|
|
3468
|
+
* __useTagsQuery__
|
|
3469
|
+
*
|
|
3470
|
+
* To run a query within a React component, call `useTagsQuery` and pass it any options that fit your needs.
|
|
3471
|
+
* When your component renders, `useTagsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3472
|
+
* you can use to render your UI.
|
|
3473
|
+
*
|
|
3474
|
+
* @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
|
|
3475
|
+
*
|
|
3476
|
+
* @example
|
|
3477
|
+
* const { data, loading, error } = useTagsQuery({
|
|
3478
|
+
* variables: {
|
|
3479
|
+
* input: // value for 'input'
|
|
3480
|
+
* },
|
|
3481
|
+
* });
|
|
3482
|
+
*/
|
|
3483
|
+
export declare function useTagsQuery(baseOptions: Apollo.QueryHookOptions<TagsQuery, TagsQueryVariables> & ({
|
|
3484
|
+
variables: TagsQueryVariables;
|
|
3485
|
+
skip?: boolean;
|
|
3486
|
+
} | {
|
|
3487
|
+
skip: boolean;
|
|
3488
|
+
})): Apollo.QueryResult<TagsQuery, Exact<{
|
|
3489
|
+
input: TagsInput;
|
|
3490
|
+
}>>;
|
|
3491
|
+
export declare function useTagsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TagsQuery, TagsQueryVariables>): Apollo.LazyQueryResultTuple<TagsQuery, Exact<{
|
|
3492
|
+
input: TagsInput;
|
|
3493
|
+
}>>;
|
|
3494
|
+
export declare function useTagsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<TagsQuery, TagsQueryVariables>): Apollo.UseSuspenseQueryResult<TagsQuery | undefined, Exact<{
|
|
3495
|
+
input: TagsInput;
|
|
3496
|
+
}>>;
|
|
3497
|
+
export type TagsQueryHookResult = ReturnType<typeof useTagsQuery>;
|
|
3498
|
+
export type TagsLazyQueryHookResult = ReturnType<typeof useTagsLazyQuery>;
|
|
3499
|
+
export type TagsSuspenseQueryHookResult = ReturnType<typeof useTagsSuspenseQuery>;
|
|
3500
|
+
export type TagsQueryResult = Apollo.QueryResult<TagsQuery, TagsQueryVariables>;
|
|
3501
|
+
export declare function refetchTagsQuery(variables: TagsQueryVariables): {
|
|
3502
|
+
query: Apollo.DocumentNode;
|
|
3503
|
+
variables: Exact<{
|
|
3504
|
+
input: TagsInput;
|
|
3505
|
+
}>;
|
|
3506
|
+
};
|
|
3507
|
+
export declare const UntagClientDocument: Apollo.DocumentNode;
|
|
3508
|
+
export type UntagClientMutationFn = Apollo.MutationFunction<UntagClientMutation, UntagClientMutationVariables>;
|
|
3509
|
+
/**
|
|
3510
|
+
* __useUntagClientMutation__
|
|
3511
|
+
*
|
|
3512
|
+
* To run a mutation, you first call `useUntagClientMutation` within a React component and pass it any options that fit your needs.
|
|
3513
|
+
* When your component renders, `useUntagClientMutation` returns a tuple that includes:
|
|
3514
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3515
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3516
|
+
*
|
|
3517
|
+
* @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;
|
|
3518
|
+
*
|
|
3519
|
+
* @example
|
|
3520
|
+
* const [untagClientMutation, { data, loading, error }] = useUntagClientMutation({
|
|
3521
|
+
* variables: {
|
|
3522
|
+
* input: // value for 'input'
|
|
3523
|
+
* },
|
|
3524
|
+
* });
|
|
3525
|
+
*/
|
|
3526
|
+
export declare function useUntagClientMutation(baseOptions?: Apollo.MutationHookOptions<UntagClientMutation, UntagClientMutationVariables>): Apollo.MutationTuple<UntagClientMutation, Exact<{
|
|
3527
|
+
input: ClientTagInput;
|
|
3528
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3529
|
+
export type UntagClientMutationHookResult = ReturnType<typeof useUntagClientMutation>;
|
|
3530
|
+
export type UntagClientMutationResult = Apollo.MutationResult<UntagClientMutation>;
|
|
3531
|
+
export type UntagClientMutationOptions = Apollo.BaseMutationOptions<UntagClientMutation, UntagClientMutationVariables>;
|
|
3532
|
+
export declare const UntagConvDocument: Apollo.DocumentNode;
|
|
3533
|
+
export type UntagConvMutationFn = Apollo.MutationFunction<UntagConvMutation, UntagConvMutationVariables>;
|
|
3534
|
+
/**
|
|
3535
|
+
* __useUntagConvMutation__
|
|
3536
|
+
*
|
|
3537
|
+
* To run a mutation, you first call `useUntagConvMutation` within a React component and pass it any options that fit your needs.
|
|
3538
|
+
* When your component renders, `useUntagConvMutation` returns a tuple that includes:
|
|
3539
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3540
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3541
|
+
*
|
|
3542
|
+
* @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;
|
|
3543
|
+
*
|
|
3544
|
+
* @example
|
|
3545
|
+
* const [untagConvMutation, { data, loading, error }] = useUntagConvMutation({
|
|
3546
|
+
* variables: {
|
|
3547
|
+
* input: // value for 'input'
|
|
3548
|
+
* },
|
|
3549
|
+
* });
|
|
3550
|
+
*/
|
|
3551
|
+
export declare function useUntagConvMutation(baseOptions?: Apollo.MutationHookOptions<UntagConvMutation, UntagConvMutationVariables>): Apollo.MutationTuple<UntagConvMutation, Exact<{
|
|
3552
|
+
input: ConvTagInput;
|
|
3553
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3554
|
+
export type UntagConvMutationHookResult = ReturnType<typeof useUntagConvMutation>;
|
|
3555
|
+
export type UntagConvMutationResult = Apollo.MutationResult<UntagConvMutation>;
|
|
3556
|
+
export type UntagConvMutationOptions = Apollo.BaseMutationOptions<UntagConvMutation, UntagConvMutationVariables>;
|
|
3557
|
+
export declare const WabaMessageTemplatesDocument: Apollo.DocumentNode;
|
|
3558
|
+
/**
|
|
3559
|
+
* __useWabaMessageTemplatesQuery__
|
|
3560
|
+
*
|
|
3561
|
+
* To run a query within a React component, call `useWabaMessageTemplatesQuery` and pass it any options that fit your needs.
|
|
3562
|
+
* When your component renders, `useWabaMessageTemplatesQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3563
|
+
* you can use to render your UI.
|
|
3564
|
+
*
|
|
3565
|
+
* @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;
|
|
3566
|
+
*
|
|
3567
|
+
* @example
|
|
3568
|
+
* const { data, loading, error } = useWabaMessageTemplatesQuery({
|
|
3569
|
+
* variables: {
|
|
3570
|
+
* input: // value for 'input'
|
|
3571
|
+
* },
|
|
3572
|
+
* });
|
|
3573
|
+
*/
|
|
3574
|
+
export declare function useWabaMessageTemplatesQuery(baseOptions: Apollo.QueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables> & ({
|
|
3575
|
+
variables: WabaMessageTemplatesQueryVariables;
|
|
3576
|
+
skip?: boolean;
|
|
3577
|
+
} | {
|
|
3578
|
+
skip: boolean;
|
|
3579
|
+
})): Apollo.QueryResult<WabaMessageTemplatesQuery, Exact<{
|
|
3580
|
+
input: WabaMessageTemplatesInput;
|
|
3581
|
+
}>>;
|
|
3582
|
+
export declare function useWabaMessageTemplatesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>): Apollo.LazyQueryResultTuple<WabaMessageTemplatesQuery, Exact<{
|
|
3583
|
+
input: WabaMessageTemplatesInput;
|
|
3584
|
+
}>>;
|
|
3585
|
+
export declare function useWabaMessageTemplatesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>): Apollo.UseSuspenseQueryResult<WabaMessageTemplatesQuery | undefined, Exact<{
|
|
3586
|
+
input: WabaMessageTemplatesInput;
|
|
3587
|
+
}>>;
|
|
3588
|
+
export type WabaMessageTemplatesQueryHookResult = ReturnType<typeof useWabaMessageTemplatesQuery>;
|
|
3589
|
+
export type WabaMessageTemplatesLazyQueryHookResult = ReturnType<typeof useWabaMessageTemplatesLazyQuery>;
|
|
3590
|
+
export type WabaMessageTemplatesSuspenseQueryHookResult = ReturnType<typeof useWabaMessageTemplatesSuspenseQuery>;
|
|
3591
|
+
export type WabaMessageTemplatesQueryResult = Apollo.QueryResult<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>;
|
|
3592
|
+
export declare function refetchWabaMessageTemplatesQuery(variables: WabaMessageTemplatesQueryVariables): {
|
|
3593
|
+
query: Apollo.DocumentNode;
|
|
3594
|
+
variables: Exact<{
|
|
3595
|
+
input: WabaMessageTemplatesInput;
|
|
3596
|
+
}>;
|
|
3597
|
+
};
|
|
3598
|
+
export declare const AiDocument: Apollo.DocumentNode;
|
|
3599
|
+
/**
|
|
3600
|
+
* __useAiQuery__
|
|
3601
|
+
*
|
|
3602
|
+
* To run a query within a React component, call `useAiQuery` and pass it any options that fit your needs.
|
|
3603
|
+
* When your component renders, `useAiQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3604
|
+
* you can use to render your UI.
|
|
3605
|
+
*
|
|
3606
|
+
* @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;
|
|
3607
|
+
*
|
|
3608
|
+
* @example
|
|
3609
|
+
* const { data, loading, error } = useAiQuery({
|
|
3610
|
+
* variables: {
|
|
3611
|
+
* input: // value for 'input'
|
|
3612
|
+
* },
|
|
3613
|
+
* });
|
|
3614
|
+
*/
|
|
3615
|
+
export declare function useAiQuery(baseOptions: Apollo.QueryHookOptions<AiQuery, AiQueryVariables> & ({
|
|
3616
|
+
variables: AiQueryVariables;
|
|
3617
|
+
skip?: boolean;
|
|
3618
|
+
} | {
|
|
3619
|
+
skip: boolean;
|
|
3620
|
+
})): Apollo.QueryResult<AiQuery, Exact<{
|
|
3621
|
+
input: AiInput;
|
|
3622
|
+
}>>;
|
|
3623
|
+
export declare function useAiLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AiQuery, AiQueryVariables>): Apollo.LazyQueryResultTuple<AiQuery, Exact<{
|
|
3624
|
+
input: AiInput;
|
|
3625
|
+
}>>;
|
|
3626
|
+
export declare function useAiSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AiQuery, AiQueryVariables>): Apollo.UseSuspenseQueryResult<AiQuery | undefined, Exact<{
|
|
3627
|
+
input: AiInput;
|
|
3628
|
+
}>>;
|
|
3629
|
+
export type AiQueryHookResult = ReturnType<typeof useAiQuery>;
|
|
3630
|
+
export type AiLazyQueryHookResult = ReturnType<typeof useAiLazyQuery>;
|
|
3631
|
+
export type AiSuspenseQueryHookResult = ReturnType<typeof useAiSuspenseQuery>;
|
|
3632
|
+
export type AiQueryResult = Apollo.QueryResult<AiQuery, AiQueryVariables>;
|
|
3633
|
+
export declare function refetchAiQuery(variables: AiQueryVariables): {
|
|
3634
|
+
query: Apollo.DocumentNode;
|
|
3635
|
+
variables: Exact<{
|
|
3636
|
+
input: AiInput;
|
|
3637
|
+
}>;
|
|
3638
|
+
};
|
|
3639
|
+
export declare const AisDocument: Apollo.DocumentNode;
|
|
3640
|
+
/**
|
|
3641
|
+
* __useAisQuery__
|
|
3642
|
+
*
|
|
3643
|
+
* To run a query within a React component, call `useAisQuery` and pass it any options that fit your needs.
|
|
3644
|
+
* When your component renders, `useAisQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3645
|
+
* you can use to render your UI.
|
|
3646
|
+
*
|
|
3647
|
+
* @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;
|
|
3648
|
+
*
|
|
3649
|
+
* @example
|
|
3650
|
+
* const { data, loading, error } = useAisQuery({
|
|
3651
|
+
* variables: {
|
|
3652
|
+
* input: // value for 'input'
|
|
3653
|
+
* },
|
|
3654
|
+
* });
|
|
3655
|
+
*/
|
|
3656
|
+
export declare function useAisQuery(baseOptions: Apollo.QueryHookOptions<AisQuery, AisQueryVariables> & ({
|
|
3657
|
+
variables: AisQueryVariables;
|
|
3658
|
+
skip?: boolean;
|
|
3659
|
+
} | {
|
|
3660
|
+
skip: boolean;
|
|
3661
|
+
})): Apollo.QueryResult<AisQuery, Exact<{
|
|
3662
|
+
input: AIsInput;
|
|
3663
|
+
}>>;
|
|
3664
|
+
export declare function useAisLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AisQuery, AisQueryVariables>): Apollo.LazyQueryResultTuple<AisQuery, Exact<{
|
|
3665
|
+
input: AIsInput;
|
|
3666
|
+
}>>;
|
|
3667
|
+
export declare function useAisSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<AisQuery, AisQueryVariables>): Apollo.UseSuspenseQueryResult<AisQuery | undefined, Exact<{
|
|
3668
|
+
input: AIsInput;
|
|
3669
|
+
}>>;
|
|
3670
|
+
export type AisQueryHookResult = ReturnType<typeof useAisQuery>;
|
|
3671
|
+
export type AisLazyQueryHookResult = ReturnType<typeof useAisLazyQuery>;
|
|
3672
|
+
export type AisSuspenseQueryHookResult = ReturnType<typeof useAisSuspenseQuery>;
|
|
3673
|
+
export type AisQueryResult = Apollo.QueryResult<AisQuery, AisQueryVariables>;
|
|
3674
|
+
export declare function refetchAisQuery(variables: AisQueryVariables): {
|
|
3675
|
+
query: Apollo.DocumentNode;
|
|
3676
|
+
variables: Exact<{
|
|
3677
|
+
input: AIsInput;
|
|
3678
|
+
}>;
|
|
3679
|
+
};
|
|
3680
|
+
export declare const ApiKeysDocument: Apollo.DocumentNode;
|
|
3681
|
+
/**
|
|
3682
|
+
* __useApiKeysQuery__
|
|
3683
|
+
*
|
|
3684
|
+
* To run a query within a React component, call `useApiKeysQuery` and pass it any options that fit your needs.
|
|
3685
|
+
* When your component renders, `useApiKeysQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
3686
|
+
* you can use to render your UI.
|
|
3687
|
+
*
|
|
3688
|
+
* @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;
|
|
3689
|
+
*
|
|
3690
|
+
* @example
|
|
3691
|
+
* const { data, loading, error } = useApiKeysQuery({
|
|
3692
|
+
* variables: {
|
|
3693
|
+
* input: // value for 'input'
|
|
3694
|
+
* },
|
|
3695
|
+
* });
|
|
3696
|
+
*/
|
|
3697
|
+
export declare function useApiKeysQuery(baseOptions: Apollo.QueryHookOptions<ApiKeysQuery, ApiKeysQueryVariables> & ({
|
|
3698
|
+
variables: ApiKeysQueryVariables;
|
|
3699
|
+
skip?: boolean;
|
|
3700
|
+
} | {
|
|
3701
|
+
skip: boolean;
|
|
3702
|
+
})): Apollo.QueryResult<ApiKeysQuery, Exact<{
|
|
3703
|
+
input: ApiKeysInput;
|
|
3704
|
+
}>>;
|
|
3705
|
+
export declare function useApiKeysLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ApiKeysQuery, ApiKeysQueryVariables>): Apollo.LazyQueryResultTuple<ApiKeysQuery, Exact<{
|
|
3706
|
+
input: ApiKeysInput;
|
|
3707
|
+
}>>;
|
|
3708
|
+
export declare function useApiKeysSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ApiKeysQuery, ApiKeysQueryVariables>): Apollo.UseSuspenseQueryResult<ApiKeysQuery | undefined, Exact<{
|
|
3709
|
+
input: ApiKeysInput;
|
|
3710
|
+
}>>;
|
|
3711
|
+
export type ApiKeysQueryHookResult = ReturnType<typeof useApiKeysQuery>;
|
|
3712
|
+
export type ApiKeysLazyQueryHookResult = ReturnType<typeof useApiKeysLazyQuery>;
|
|
3713
|
+
export type ApiKeysSuspenseQueryHookResult = ReturnType<typeof useApiKeysSuspenseQuery>;
|
|
3714
|
+
export type ApiKeysQueryResult = Apollo.QueryResult<ApiKeysQuery, ApiKeysQueryVariables>;
|
|
3715
|
+
export declare function refetchApiKeysQuery(variables: ApiKeysQueryVariables): {
|
|
3716
|
+
query: Apollo.DocumentNode;
|
|
3717
|
+
variables: Exact<{
|
|
3718
|
+
input: ApiKeysInput;
|
|
3719
|
+
}>;
|
|
3720
|
+
};
|
|
3721
|
+
export declare const BulkPatchTagsDocument: Apollo.DocumentNode;
|
|
3722
|
+
export type BulkPatchTagsMutationFn = Apollo.MutationFunction<BulkPatchTagsMutation, BulkPatchTagsMutationVariables>;
|
|
3723
|
+
/**
|
|
3724
|
+
* __useBulkPatchTagsMutation__
|
|
3725
|
+
*
|
|
3726
|
+
* To run a mutation, you first call `useBulkPatchTagsMutation` within a React component and pass it any options that fit your needs.
|
|
3727
|
+
* When your component renders, `useBulkPatchTagsMutation` returns a tuple that includes:
|
|
3728
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3729
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3730
|
+
*
|
|
3731
|
+
* @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;
|
|
3732
|
+
*
|
|
3733
|
+
* @example
|
|
3734
|
+
* const [bulkPatchTagsMutation, { data, loading, error }] = useBulkPatchTagsMutation({
|
|
3735
|
+
* variables: {
|
|
3736
|
+
* input: // value for 'input'
|
|
3737
|
+
* },
|
|
3738
|
+
* });
|
|
3739
|
+
*/
|
|
3740
|
+
export declare function useBulkPatchTagsMutation(baseOptions?: Apollo.MutationHookOptions<BulkPatchTagsMutation, BulkPatchTagsMutationVariables>): Apollo.MutationTuple<BulkPatchTagsMutation, Exact<{
|
|
3741
|
+
input: TagBulkPatchInput;
|
|
3742
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3743
|
+
export type BulkPatchTagsMutationHookResult = ReturnType<typeof useBulkPatchTagsMutation>;
|
|
3744
|
+
export type BulkPatchTagsMutationResult = Apollo.MutationResult<BulkPatchTagsMutation>;
|
|
3745
|
+
export type BulkPatchTagsMutationOptions = Apollo.BaseMutationOptions<BulkPatchTagsMutation, BulkPatchTagsMutationVariables>;
|
|
3746
|
+
export declare const CreateAiDocument: Apollo.DocumentNode;
|
|
3747
|
+
export type CreateAiMutationFn = Apollo.MutationFunction<CreateAiMutation, CreateAiMutationVariables>;
|
|
3748
|
+
/**
|
|
3749
|
+
* __useCreateAiMutation__
|
|
3750
|
+
*
|
|
3751
|
+
* To run a mutation, you first call `useCreateAiMutation` within a React component and pass it any options that fit your needs.
|
|
3752
|
+
* When your component renders, `useCreateAiMutation` returns a tuple that includes:
|
|
3753
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3754
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3755
|
+
*
|
|
3756
|
+
* @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;
|
|
3757
|
+
*
|
|
3758
|
+
* @example
|
|
3759
|
+
* const [createAiMutation, { data, loading, error }] = useCreateAiMutation({
|
|
3760
|
+
* variables: {
|
|
3761
|
+
* input: // value for 'input'
|
|
3762
|
+
* },
|
|
3763
|
+
* });
|
|
3764
|
+
*/
|
|
3765
|
+
export declare function useCreateAiMutation(baseOptions?: Apollo.MutationHookOptions<CreateAiMutation, CreateAiMutationVariables>): Apollo.MutationTuple<CreateAiMutation, Exact<{
|
|
3766
|
+
input: AiCreateInput;
|
|
3767
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3768
|
+
export type CreateAiMutationHookResult = ReturnType<typeof useCreateAiMutation>;
|
|
3769
|
+
export type CreateAiMutationResult = Apollo.MutationResult<CreateAiMutation>;
|
|
3770
|
+
export type CreateAiMutationOptions = Apollo.BaseMutationOptions<CreateAiMutation, CreateAiMutationVariables>;
|
|
3771
|
+
export declare const CreateIntegrationDocument: Apollo.DocumentNode;
|
|
3772
|
+
export type CreateIntegrationMutationFn = Apollo.MutationFunction<CreateIntegrationMutation, CreateIntegrationMutationVariables>;
|
|
3773
|
+
/**
|
|
3774
|
+
* __useCreateIntegrationMutation__
|
|
3775
|
+
*
|
|
3776
|
+
* To run a mutation, you first call `useCreateIntegrationMutation` within a React component and pass it any options that fit your needs.
|
|
3777
|
+
* When your component renders, `useCreateIntegrationMutation` returns a tuple that includes:
|
|
3778
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3779
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3780
|
+
*
|
|
3781
|
+
* @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;
|
|
3782
|
+
*
|
|
3783
|
+
* @example
|
|
3784
|
+
* const [createIntegrationMutation, { data, loading, error }] = useCreateIntegrationMutation({
|
|
3785
|
+
* variables: {
|
|
3786
|
+
* input: // value for 'input'
|
|
3787
|
+
* },
|
|
3788
|
+
* });
|
|
3789
|
+
*/
|
|
3790
|
+
export declare function useCreateIntegrationMutation(baseOptions?: Apollo.MutationHookOptions<CreateIntegrationMutation, CreateIntegrationMutationVariables>): Apollo.MutationTuple<CreateIntegrationMutation, Exact<{
|
|
3791
|
+
input: IntegrationCreateInput;
|
|
3792
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3793
|
+
export type CreateIntegrationMutationHookResult = ReturnType<typeof useCreateIntegrationMutation>;
|
|
3794
|
+
export type CreateIntegrationMutationResult = Apollo.MutationResult<CreateIntegrationMutation>;
|
|
3795
|
+
export type CreateIntegrationMutationOptions = Apollo.BaseMutationOptions<CreateIntegrationMutation, CreateIntegrationMutationVariables>;
|
|
3796
|
+
export declare const CreateTagDocument: Apollo.DocumentNode;
|
|
3797
|
+
export type CreateTagMutationFn = Apollo.MutationFunction<CreateTagMutation, CreateTagMutationVariables>;
|
|
3798
|
+
/**
|
|
3799
|
+
* __useCreateTagMutation__
|
|
3800
|
+
*
|
|
3801
|
+
* To run a mutation, you first call `useCreateTagMutation` within a React component and pass it any options that fit your needs.
|
|
3802
|
+
* When your component renders, `useCreateTagMutation` returns a tuple that includes:
|
|
3803
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3804
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3805
|
+
*
|
|
3806
|
+
* @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;
|
|
3807
|
+
*
|
|
3808
|
+
* @example
|
|
3809
|
+
* const [createTagMutation, { data, loading, error }] = useCreateTagMutation({
|
|
3810
|
+
* variables: {
|
|
3811
|
+
* input: // value for 'input'
|
|
3812
|
+
* },
|
|
3813
|
+
* });
|
|
3814
|
+
*/
|
|
3815
|
+
export declare function useCreateTagMutation(baseOptions?: Apollo.MutationHookOptions<CreateTagMutation, CreateTagMutationVariables>): Apollo.MutationTuple<CreateTagMutation, Exact<{
|
|
3816
|
+
input: TagCreateInput;
|
|
3817
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3818
|
+
export type CreateTagMutationHookResult = ReturnType<typeof useCreateTagMutation>;
|
|
3819
|
+
export type CreateTagMutationResult = Apollo.MutationResult<CreateTagMutation>;
|
|
3820
|
+
export type CreateTagMutationOptions = Apollo.BaseMutationOptions<CreateTagMutation, CreateTagMutationVariables>;
|
|
3821
|
+
export declare const CreateWebhookDocument: Apollo.DocumentNode;
|
|
3822
|
+
export type CreateWebhookMutationFn = Apollo.MutationFunction<CreateWebhookMutation, CreateWebhookMutationVariables>;
|
|
3823
|
+
/**
|
|
3824
|
+
* __useCreateWebhookMutation__
|
|
3825
|
+
*
|
|
3826
|
+
* To run a mutation, you first call `useCreateWebhookMutation` within a React component and pass it any options that fit your needs.
|
|
3827
|
+
* When your component renders, `useCreateWebhookMutation` returns a tuple that includes:
|
|
3828
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3829
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3830
|
+
*
|
|
3831
|
+
* @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;
|
|
3832
|
+
*
|
|
3833
|
+
* @example
|
|
3834
|
+
* const [createWebhookMutation, { data, loading, error }] = useCreateWebhookMutation({
|
|
3835
|
+
* variables: {
|
|
3836
|
+
* input: // value for 'input'
|
|
3837
|
+
* },
|
|
3838
|
+
* });
|
|
3839
|
+
*/
|
|
3840
|
+
export declare function useCreateWebhookMutation(baseOptions?: Apollo.MutationHookOptions<CreateWebhookMutation, CreateWebhookMutationVariables>): Apollo.MutationTuple<CreateWebhookMutation, Exact<{
|
|
3841
|
+
input: WebhookCreateInput;
|
|
3842
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3843
|
+
export type CreateWebhookMutationHookResult = ReturnType<typeof useCreateWebhookMutation>;
|
|
3844
|
+
export type CreateWebhookMutationResult = Apollo.MutationResult<CreateWebhookMutation>;
|
|
3845
|
+
export type CreateWebhookMutationOptions = Apollo.BaseMutationOptions<CreateWebhookMutation, CreateWebhookMutationVariables>;
|
|
3846
|
+
export declare const DeleteAiDocument: Apollo.DocumentNode;
|
|
3847
|
+
export type DeleteAiMutationFn = Apollo.MutationFunction<DeleteAiMutation, DeleteAiMutationVariables>;
|
|
3848
|
+
/**
|
|
3849
|
+
* __useDeleteAiMutation__
|
|
3850
|
+
*
|
|
3851
|
+
* To run a mutation, you first call `useDeleteAiMutation` within a React component and pass it any options that fit your needs.
|
|
3852
|
+
* When your component renders, `useDeleteAiMutation` returns a tuple that includes:
|
|
3853
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3854
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3855
|
+
*
|
|
3856
|
+
* @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;
|
|
3857
|
+
*
|
|
3858
|
+
* @example
|
|
3859
|
+
* const [deleteAiMutation, { data, loading, error }] = useDeleteAiMutation({
|
|
3860
|
+
* variables: {
|
|
3861
|
+
* input: // value for 'input'
|
|
3862
|
+
* },
|
|
3863
|
+
* });
|
|
3864
|
+
*/
|
|
3865
|
+
export declare function useDeleteAiMutation(baseOptions?: Apollo.MutationHookOptions<DeleteAiMutation, DeleteAiMutationVariables>): Apollo.MutationTuple<DeleteAiMutation, Exact<{
|
|
3866
|
+
input: AiDeleteInput;
|
|
3867
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3868
|
+
export type DeleteAiMutationHookResult = ReturnType<typeof useDeleteAiMutation>;
|
|
3869
|
+
export type DeleteAiMutationResult = Apollo.MutationResult<DeleteAiMutation>;
|
|
3870
|
+
export type DeleteAiMutationOptions = Apollo.BaseMutationOptions<DeleteAiMutation, DeleteAiMutationVariables>;
|
|
3871
|
+
export declare const DeleteApiKeyDocument: Apollo.DocumentNode;
|
|
3872
|
+
export type DeleteApiKeyMutationFn = Apollo.MutationFunction<DeleteApiKeyMutation, DeleteApiKeyMutationVariables>;
|
|
3873
|
+
/**
|
|
3874
|
+
* __useDeleteApiKeyMutation__
|
|
3875
|
+
*
|
|
3876
|
+
* To run a mutation, you first call `useDeleteApiKeyMutation` within a React component and pass it any options that fit your needs.
|
|
3877
|
+
* When your component renders, `useDeleteApiKeyMutation` returns a tuple that includes:
|
|
3878
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3879
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3880
|
+
*
|
|
3881
|
+
* @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;
|
|
3882
|
+
*
|
|
3883
|
+
* @example
|
|
3884
|
+
* const [deleteApiKeyMutation, { data, loading, error }] = useDeleteApiKeyMutation({
|
|
3885
|
+
* variables: {
|
|
3886
|
+
* input: // value for 'input'
|
|
3887
|
+
* },
|
|
3888
|
+
* });
|
|
3889
|
+
*/
|
|
3890
|
+
export declare function useDeleteApiKeyMutation(baseOptions?: Apollo.MutationHookOptions<DeleteApiKeyMutation, DeleteApiKeyMutationVariables>): Apollo.MutationTuple<DeleteApiKeyMutation, Exact<{
|
|
3891
|
+
input: ApiKeyDeleteInput;
|
|
3892
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3893
|
+
export type DeleteApiKeyMutationHookResult = ReturnType<typeof useDeleteApiKeyMutation>;
|
|
3894
|
+
export type DeleteApiKeyMutationResult = Apollo.MutationResult<DeleteApiKeyMutation>;
|
|
3895
|
+
export type DeleteApiKeyMutationOptions = Apollo.BaseMutationOptions<DeleteApiKeyMutation, DeleteApiKeyMutationVariables>;
|
|
3896
|
+
export declare const DeleteIntegrationDocument: Apollo.DocumentNode;
|
|
3897
|
+
export type DeleteIntegrationMutationFn = Apollo.MutationFunction<DeleteIntegrationMutation, DeleteIntegrationMutationVariables>;
|
|
3898
|
+
/**
|
|
3899
|
+
* __useDeleteIntegrationMutation__
|
|
3900
|
+
*
|
|
3901
|
+
* To run a mutation, you first call `useDeleteIntegrationMutation` within a React component and pass it any options that fit your needs.
|
|
3902
|
+
* When your component renders, `useDeleteIntegrationMutation` returns a tuple that includes:
|
|
3903
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3904
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3905
|
+
*
|
|
3906
|
+
* @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;
|
|
3907
|
+
*
|
|
3908
|
+
* @example
|
|
3909
|
+
* const [deleteIntegrationMutation, { data, loading, error }] = useDeleteIntegrationMutation({
|
|
3910
|
+
* variables: {
|
|
3911
|
+
* input: // value for 'input'
|
|
3912
|
+
* },
|
|
3913
|
+
* });
|
|
3914
|
+
*/
|
|
3915
|
+
export declare function useDeleteIntegrationMutation(baseOptions?: Apollo.MutationHookOptions<DeleteIntegrationMutation, DeleteIntegrationMutationVariables>): Apollo.MutationTuple<DeleteIntegrationMutation, Exact<{
|
|
3916
|
+
input: IntegrationDeleteInput;
|
|
3917
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3918
|
+
export type DeleteIntegrationMutationHookResult = ReturnType<typeof useDeleteIntegrationMutation>;
|
|
3919
|
+
export type DeleteIntegrationMutationResult = Apollo.MutationResult<DeleteIntegrationMutation>;
|
|
3920
|
+
export type DeleteIntegrationMutationOptions = Apollo.BaseMutationOptions<DeleteIntegrationMutation, DeleteIntegrationMutationVariables>;
|
|
3921
|
+
export declare const DeleteTagDocument: Apollo.DocumentNode;
|
|
3922
|
+
export type DeleteTagMutationFn = Apollo.MutationFunction<DeleteTagMutation, DeleteTagMutationVariables>;
|
|
3923
|
+
/**
|
|
3924
|
+
* __useDeleteTagMutation__
|
|
3925
|
+
*
|
|
3926
|
+
* To run a mutation, you first call `useDeleteTagMutation` within a React component and pass it any options that fit your needs.
|
|
3927
|
+
* When your component renders, `useDeleteTagMutation` returns a tuple that includes:
|
|
3928
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3929
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3930
|
+
*
|
|
3931
|
+
* @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;
|
|
3932
|
+
*
|
|
3933
|
+
* @example
|
|
3934
|
+
* const [deleteTagMutation, { data, loading, error }] = useDeleteTagMutation({
|
|
3935
|
+
* variables: {
|
|
3936
|
+
* input: // value for 'input'
|
|
3937
|
+
* },
|
|
3938
|
+
* });
|
|
3939
|
+
*/
|
|
3940
|
+
export declare function useDeleteTagMutation(baseOptions?: Apollo.MutationHookOptions<DeleteTagMutation, DeleteTagMutationVariables>): Apollo.MutationTuple<DeleteTagMutation, Exact<{
|
|
3941
|
+
input: TagDeleteInput;
|
|
3942
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3943
|
+
export type DeleteTagMutationHookResult = ReturnType<typeof useDeleteTagMutation>;
|
|
3944
|
+
export type DeleteTagMutationResult = Apollo.MutationResult<DeleteTagMutation>;
|
|
3945
|
+
export type DeleteTagMutationOptions = Apollo.BaseMutationOptions<DeleteTagMutation, DeleteTagMutationVariables>;
|
|
3946
|
+
export declare const DeleteWebhookDocument: Apollo.DocumentNode;
|
|
3947
|
+
export type DeleteWebhookMutationFn = Apollo.MutationFunction<DeleteWebhookMutation, DeleteWebhookMutationVariables>;
|
|
3948
|
+
/**
|
|
3949
|
+
* __useDeleteWebhookMutation__
|
|
3950
|
+
*
|
|
3951
|
+
* To run a mutation, you first call `useDeleteWebhookMutation` within a React component and pass it any options that fit your needs.
|
|
3952
|
+
* When your component renders, `useDeleteWebhookMutation` returns a tuple that includes:
|
|
3953
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3954
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3955
|
+
*
|
|
3956
|
+
* @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;
|
|
3957
|
+
*
|
|
3958
|
+
* @example
|
|
3959
|
+
* const [deleteWebhookMutation, { data, loading, error }] = useDeleteWebhookMutation({
|
|
3960
|
+
* variables: {
|
|
3961
|
+
* input: // value for 'input'
|
|
3962
|
+
* },
|
|
3963
|
+
* });
|
|
3964
|
+
*/
|
|
3965
|
+
export declare function useDeleteWebhookMutation(baseOptions?: Apollo.MutationHookOptions<DeleteWebhookMutation, DeleteWebhookMutationVariables>): Apollo.MutationTuple<DeleteWebhookMutation, Exact<{
|
|
3966
|
+
input: WebhookDeleteInput;
|
|
3967
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3968
|
+
export type DeleteWebhookMutationHookResult = ReturnType<typeof useDeleteWebhookMutation>;
|
|
3969
|
+
export type DeleteWebhookMutationResult = Apollo.MutationResult<DeleteWebhookMutation>;
|
|
3970
|
+
export type DeleteWebhookMutationOptions = Apollo.BaseMutationOptions<DeleteWebhookMutation, DeleteWebhookMutationVariables>;
|
|
3971
|
+
export declare const GenApiKeyDocument: Apollo.DocumentNode;
|
|
3972
|
+
export type GenApiKeyMutationFn = Apollo.MutationFunction<GenApiKeyMutation, GenApiKeyMutationVariables>;
|
|
3973
|
+
/**
|
|
3974
|
+
* __useGenApiKeyMutation__
|
|
3975
|
+
*
|
|
3976
|
+
* To run a mutation, you first call `useGenApiKeyMutation` within a React component and pass it any options that fit your needs.
|
|
3977
|
+
* When your component renders, `useGenApiKeyMutation` returns a tuple that includes:
|
|
3978
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
3979
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
3980
|
+
*
|
|
3981
|
+
* @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;
|
|
3982
|
+
*
|
|
3983
|
+
* @example
|
|
3984
|
+
* const [genApiKeyMutation, { data, loading, error }] = useGenApiKeyMutation({
|
|
3985
|
+
* variables: {
|
|
3986
|
+
* input: // value for 'input'
|
|
3987
|
+
* },
|
|
3988
|
+
* });
|
|
3989
|
+
*/
|
|
3990
|
+
export declare function useGenApiKeyMutation(baseOptions?: Apollo.MutationHookOptions<GenApiKeyMutation, GenApiKeyMutationVariables>): Apollo.MutationTuple<GenApiKeyMutation, Exact<{
|
|
3991
|
+
input: ApiKeyGenInput;
|
|
3992
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
3993
|
+
export type GenApiKeyMutationHookResult = ReturnType<typeof useGenApiKeyMutation>;
|
|
3994
|
+
export type GenApiKeyMutationResult = Apollo.MutationResult<GenApiKeyMutation>;
|
|
3995
|
+
export type GenApiKeyMutationOptions = Apollo.BaseMutationOptions<GenApiKeyMutation, GenApiKeyMutationVariables>;
|
|
3996
|
+
export declare const IntegrationDocument: Apollo.DocumentNode;
|
|
3997
|
+
/**
|
|
3998
|
+
* __useIntegrationQuery__
|
|
3999
|
+
*
|
|
4000
|
+
* To run a query within a React component, call `useIntegrationQuery` and pass it any options that fit your needs.
|
|
4001
|
+
* When your component renders, `useIntegrationQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
4002
|
+
* you can use to render your UI.
|
|
4003
|
+
*
|
|
4004
|
+
* @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;
|
|
4005
|
+
*
|
|
4006
|
+
* @example
|
|
4007
|
+
* const { data, loading, error } = useIntegrationQuery({
|
|
4008
|
+
* variables: {
|
|
4009
|
+
* input: // value for 'input'
|
|
4010
|
+
* },
|
|
4011
|
+
* });
|
|
4012
|
+
*/
|
|
4013
|
+
export declare function useIntegrationQuery(baseOptions: Apollo.QueryHookOptions<IntegrationQuery, IntegrationQueryVariables> & ({
|
|
4014
|
+
variables: IntegrationQueryVariables;
|
|
4015
|
+
skip?: boolean;
|
|
4016
|
+
} | {
|
|
4017
|
+
skip: boolean;
|
|
4018
|
+
})): Apollo.QueryResult<IntegrationQuery, Exact<{
|
|
4019
|
+
input: IntegrationInput;
|
|
4020
|
+
}>>;
|
|
4021
|
+
export declare function useIntegrationLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IntegrationQuery, IntegrationQueryVariables>): Apollo.LazyQueryResultTuple<IntegrationQuery, Exact<{
|
|
4022
|
+
input: IntegrationInput;
|
|
4023
|
+
}>>;
|
|
4024
|
+
export declare function useIntegrationSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IntegrationQuery, IntegrationQueryVariables>): Apollo.UseSuspenseQueryResult<IntegrationQuery | undefined, Exact<{
|
|
4025
|
+
input: IntegrationInput;
|
|
4026
|
+
}>>;
|
|
4027
|
+
export type IntegrationQueryHookResult = ReturnType<typeof useIntegrationQuery>;
|
|
4028
|
+
export type IntegrationLazyQueryHookResult = ReturnType<typeof useIntegrationLazyQuery>;
|
|
4029
|
+
export type IntegrationSuspenseQueryHookResult = ReturnType<typeof useIntegrationSuspenseQuery>;
|
|
4030
|
+
export type IntegrationQueryResult = Apollo.QueryResult<IntegrationQuery, IntegrationQueryVariables>;
|
|
4031
|
+
export declare function refetchIntegrationQuery(variables: IntegrationQueryVariables): {
|
|
4032
|
+
query: Apollo.DocumentNode;
|
|
4033
|
+
variables: Exact<{
|
|
4034
|
+
input: IntegrationInput;
|
|
4035
|
+
}>;
|
|
4036
|
+
};
|
|
4037
|
+
export declare const IntegrationsDocument: Apollo.DocumentNode;
|
|
4038
|
+
/**
|
|
4039
|
+
* __useIntegrationsQuery__
|
|
4040
|
+
*
|
|
4041
|
+
* To run a query within a React component, call `useIntegrationsQuery` and pass it any options that fit your needs.
|
|
4042
|
+
* When your component renders, `useIntegrationsQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
4043
|
+
* you can use to render your UI.
|
|
4044
|
+
*
|
|
4045
|
+
* @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;
|
|
4046
|
+
*
|
|
4047
|
+
* @example
|
|
4048
|
+
* const { data, loading, error } = useIntegrationsQuery({
|
|
4049
|
+
* variables: {
|
|
4050
|
+
* input: // value for 'input'
|
|
4051
|
+
* },
|
|
4052
|
+
* });
|
|
4053
|
+
*/
|
|
4054
|
+
export declare function useIntegrationsQuery(baseOptions: Apollo.QueryHookOptions<IntegrationsQuery, IntegrationsQueryVariables> & ({
|
|
4055
|
+
variables: IntegrationsQueryVariables;
|
|
4056
|
+
skip?: boolean;
|
|
4057
|
+
} | {
|
|
4058
|
+
skip: boolean;
|
|
4059
|
+
})): Apollo.QueryResult<IntegrationsQuery, Exact<{
|
|
4060
|
+
input: IntegrationsInput;
|
|
4061
|
+
}>>;
|
|
4062
|
+
export declare function useIntegrationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IntegrationsQuery, IntegrationsQueryVariables>): Apollo.LazyQueryResultTuple<IntegrationsQuery, Exact<{
|
|
4063
|
+
input: IntegrationsInput;
|
|
4064
|
+
}>>;
|
|
4065
|
+
export declare function useIntegrationsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IntegrationsQuery, IntegrationsQueryVariables>): Apollo.UseSuspenseQueryResult<IntegrationsQuery | undefined, Exact<{
|
|
4066
|
+
input: IntegrationsInput;
|
|
4067
|
+
}>>;
|
|
4068
|
+
export type IntegrationsQueryHookResult = ReturnType<typeof useIntegrationsQuery>;
|
|
4069
|
+
export type IntegrationsLazyQueryHookResult = ReturnType<typeof useIntegrationsLazyQuery>;
|
|
4070
|
+
export type IntegrationsSuspenseQueryHookResult = ReturnType<typeof useIntegrationsSuspenseQuery>;
|
|
4071
|
+
export type IntegrationsQueryResult = Apollo.QueryResult<IntegrationsQuery, IntegrationsQueryVariables>;
|
|
4072
|
+
export declare function refetchIntegrationsQuery(variables: IntegrationsQueryVariables): {
|
|
4073
|
+
query: Apollo.DocumentNode;
|
|
4074
|
+
variables: Exact<{
|
|
4075
|
+
input: IntegrationsInput;
|
|
4076
|
+
}>;
|
|
4077
|
+
};
|
|
4078
|
+
export declare const PatchAiDocument: Apollo.DocumentNode;
|
|
4079
|
+
export type PatchAiMutationFn = Apollo.MutationFunction<PatchAiMutation, PatchAiMutationVariables>;
|
|
4080
|
+
/**
|
|
4081
|
+
* __usePatchAiMutation__
|
|
4082
|
+
*
|
|
4083
|
+
* To run a mutation, you first call `usePatchAiMutation` within a React component and pass it any options that fit your needs.
|
|
4084
|
+
* When your component renders, `usePatchAiMutation` returns a tuple that includes:
|
|
4085
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
4086
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
4087
|
+
*
|
|
4088
|
+
* @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;
|
|
4089
|
+
*
|
|
4090
|
+
* @example
|
|
4091
|
+
* const [patchAiMutation, { data, loading, error }] = usePatchAiMutation({
|
|
4092
|
+
* variables: {
|
|
4093
|
+
* input: // value for 'input'
|
|
4094
|
+
* },
|
|
4095
|
+
* });
|
|
4096
|
+
*/
|
|
4097
|
+
export declare function usePatchAiMutation(baseOptions?: Apollo.MutationHookOptions<PatchAiMutation, PatchAiMutationVariables>): Apollo.MutationTuple<PatchAiMutation, Exact<{
|
|
4098
|
+
input: AiPatchInput;
|
|
4099
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
4100
|
+
export type PatchAiMutationHookResult = ReturnType<typeof usePatchAiMutation>;
|
|
4101
|
+
export type PatchAiMutationResult = Apollo.MutationResult<PatchAiMutation>;
|
|
4102
|
+
export type PatchAiMutationOptions = Apollo.BaseMutationOptions<PatchAiMutation, PatchAiMutationVariables>;
|
|
4103
|
+
export declare const PatchIntegrationDocument: Apollo.DocumentNode;
|
|
4104
|
+
export type PatchIntegrationMutationFn = Apollo.MutationFunction<PatchIntegrationMutation, PatchIntegrationMutationVariables>;
|
|
4105
|
+
/**
|
|
4106
|
+
* __usePatchIntegrationMutation__
|
|
4107
|
+
*
|
|
4108
|
+
* To run a mutation, you first call `usePatchIntegrationMutation` within a React component and pass it any options that fit your needs.
|
|
4109
|
+
* When your component renders, `usePatchIntegrationMutation` returns a tuple that includes:
|
|
4110
|
+
* - A mutate function that you can call at any time to execute the mutation
|
|
4111
|
+
* - An object with fields that represent the current status of the mutation's execution
|
|
4112
|
+
*
|
|
4113
|
+
* @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;
|
|
4114
|
+
*
|
|
4115
|
+
* @example
|
|
4116
|
+
* const [patchIntegrationMutation, { data, loading, error }] = usePatchIntegrationMutation({
|
|
4117
|
+
* variables: {
|
|
4118
|
+
* input: // value for 'input'
|
|
4119
|
+
* },
|
|
4120
|
+
* });
|
|
4121
|
+
*/
|
|
4122
|
+
export declare function usePatchIntegrationMutation(baseOptions?: Apollo.MutationHookOptions<PatchIntegrationMutation, PatchIntegrationMutationVariables>): Apollo.MutationTuple<PatchIntegrationMutation, Exact<{
|
|
4123
|
+
input: IntegrationPatchInput;
|
|
4124
|
+
}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
|
|
4125
|
+
export type PatchIntegrationMutationHookResult = ReturnType<typeof usePatchIntegrationMutation>;
|
|
4126
|
+
export type PatchIntegrationMutationResult = Apollo.MutationResult<PatchIntegrationMutation>;
|
|
4127
|
+
export type PatchIntegrationMutationOptions = Apollo.BaseMutationOptions<PatchIntegrationMutation, PatchIntegrationMutationVariables>;
|
|
4128
|
+
export declare const WebhooksDocument: Apollo.DocumentNode;
|
|
4129
|
+
/**
|
|
4130
|
+
* __useWebhooksQuery__
|
|
4131
|
+
*
|
|
4132
|
+
* To run a query within a React component, call `useWebhooksQuery` and pass it any options that fit your needs.
|
|
4133
|
+
* When your component renders, `useWebhooksQuery` returns an object from Apollo Client that contains loading, error, and data properties
|
|
4134
|
+
* you can use to render your UI.
|
|
4135
|
+
*
|
|
4136
|
+
* @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;
|
|
4137
|
+
*
|
|
4138
|
+
* @example
|
|
4139
|
+
* const { data, loading, error } = useWebhooksQuery({
|
|
4140
|
+
* variables: {
|
|
4141
|
+
* input: // value for 'input'
|
|
4142
|
+
* },
|
|
4143
|
+
* });
|
|
4144
|
+
*/
|
|
4145
|
+
export declare function useWebhooksQuery(baseOptions: Apollo.QueryHookOptions<WebhooksQuery, WebhooksQueryVariables> & ({
|
|
4146
|
+
variables: WebhooksQueryVariables;
|
|
4147
|
+
skip?: boolean;
|
|
4148
|
+
} | {
|
|
4149
|
+
skip: boolean;
|
|
4150
|
+
})): Apollo.QueryResult<WebhooksQuery, Exact<{
|
|
4151
|
+
input: WebhooksInput;
|
|
4152
|
+
}>>;
|
|
4153
|
+
export declare function useWebhooksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<WebhooksQuery, WebhooksQueryVariables>): Apollo.LazyQueryResultTuple<WebhooksQuery, Exact<{
|
|
4154
|
+
input: WebhooksInput;
|
|
4155
|
+
}>>;
|
|
4156
|
+
export declare function useWebhooksSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<WebhooksQuery, WebhooksQueryVariables>): Apollo.UseSuspenseQueryResult<WebhooksQuery | undefined, Exact<{
|
|
4157
|
+
input: WebhooksInput;
|
|
4158
|
+
}>>;
|
|
4159
|
+
export type WebhooksQueryHookResult = ReturnType<typeof useWebhooksQuery>;
|
|
4160
|
+
export type WebhooksLazyQueryHookResult = ReturnType<typeof useWebhooksLazyQuery>;
|
|
4161
|
+
export type WebhooksSuspenseQueryHookResult = ReturnType<typeof useWebhooksSuspenseQuery>;
|
|
4162
|
+
export type WebhooksQueryResult = Apollo.QueryResult<WebhooksQuery, WebhooksQueryVariables>;
|
|
4163
|
+
export declare function refetchWebhooksQuery(variables: WebhooksQueryVariables): {
|
|
4164
|
+
query: Apollo.DocumentNode;
|
|
4165
|
+
variables: Exact<{
|
|
4166
|
+
input: WebhooksInput;
|
|
4167
|
+
}>;
|
|
4168
|
+
};
|