@bcrumbs.net/inbox 0.0.44 → 0.0.45

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.

Potentially problematic release.


This version of @bcrumbs.net/inbox might be problematic. Click here for more details.

@@ -152,7 +152,7 @@ export type AgentCreateInput = {
152
152
  /** The name of the agent. */
153
153
  name: Scalars['String']['input'];
154
154
  /** The surname of the agent. */
155
- surname: Scalars['String']['input'];
155
+ surname?: InputMaybe<Scalars['String']['input']>;
156
156
  /** The user id of the agent. It is the same as the user id of the invited user to the workspace. */
157
157
  userId: Scalars['String']['input'];
158
158
  workspaceId: Scalars['Int']['input'];
@@ -168,7 +168,7 @@ export type AgentPatchInput = {
168
168
  /** The name of the agent. */
169
169
  name: Scalars['String']['input'];
170
170
  /** The surname of the agent. */
171
- surname: Scalars['String']['input'];
171
+ surname?: InputMaybe<Scalars['String']['input']>;
172
172
  workspaceId: Scalars['Int']['input'];
173
173
  };
174
174
  /** AgentReport is a report of the agent breaked down by day. It is used to understand the agent's performance. */
@@ -526,6 +526,38 @@ export type BroadcastPatchInput = {
526
526
  templateName: Scalars['String']['input'];
527
527
  workspaceId: Scalars['Int']['input'];
528
528
  };
529
+ /** BroadcastReport tracks daily broadcast notification usage broken down by hour, differentiating between successful and failed sends. */
530
+ export type BroadcastReport = {
531
+ __typename?: 'BroadcastReport';
532
+ /** The date and time when the report was created. */
533
+ createdAt: Scalars['DateTime']['output'];
534
+ /** The number of notifications that failed in this hour. */
535
+ failedCount: Scalars['Int']['output'];
536
+ /** The hour of the day (0-23) the report covers. */
537
+ hour: Scalars['Int']['output'];
538
+ /** The id of the broadcast report. */
539
+ id: Scalars['ID']['output'];
540
+ /** The integration/channel id associated with the report. */
541
+ integrationId: Scalars['ID']['output'];
542
+ /** The number of notifications successfully sent in this hour. */
543
+ successCount: Scalars['Int']['output'];
544
+ workspaceId: Scalars['Int']['output'];
545
+ };
546
+ /** BroadcastReportInput is an input of the broadcast report query. */
547
+ export type BroadcastReportInput = {
548
+ /** The end date of the report range. */
549
+ endDate: Scalars['DateTime']['input'];
550
+ /** The integration/channel id to filter reports by. */
551
+ integrationId?: InputMaybe<Scalars['ID']['input']>;
552
+ /** The start date of the report range. */
553
+ startDate: Scalars['DateTime']['input'];
554
+ workspaceId: Scalars['Int']['input'];
555
+ };
556
+ /** BroadcastReportPayload is a payload of the broadcast report query. */
557
+ export type BroadcastReportPayload = {
558
+ __typename?: 'BroadcastReportPayload';
559
+ nodes?: Maybe<Array<BroadcastReport>>;
560
+ };
529
561
  /**
530
562
  * BroadcastState is the state of the broadcast.
531
563
  * - draft: The broadcast is in draft mode.
@@ -642,6 +674,8 @@ export type Client = {
642
674
  __typename?: 'Client';
643
675
  /** The address of the client. It can be modified by the user. */
644
676
  address?: Maybe<Scalars['String']['output']>;
677
+ /** The identifier of the user or agent who archived this client. Null if archived by system. */
678
+ archivedBy?: Maybe<Scalars['String']['output']>;
645
679
  /** The city of the client. It can be modified by the user. */
646
680
  city?: Maybe<Scalars['String']['output']>;
647
681
  /** The code of the client. It can be modified by the user. */
@@ -901,6 +935,12 @@ export type ConvEndInput = {
901
935
  integrationId: Scalars['ID']['input'];
902
936
  workspaceId: Scalars['Int']['input'];
903
937
  };
938
+ /** ConvLastMessageInput is an input for getting the last message of an open conversation. */
939
+ export type ConvLastMessageInput = {
940
+ /** The id of the conversation. */
941
+ convId: Scalars['ID']['input'];
942
+ workspaceId: Scalars['Int']['input'];
943
+ };
904
944
  /** ConvPatchInput is an input of the conversation patch mutation. */
905
945
  export type ConvPatchInput = {
906
946
  /** The id of the conversation. */
@@ -1191,6 +1231,8 @@ export type Integration = {
1191
1231
  deletedAt?: Maybe<Scalars['DateTime']['output']>;
1192
1232
  /** The id of the integration. */
1193
1233
  id: Scalars['ID']['output'];
1234
+ /** The integration identifier. */
1235
+ identifier?: Maybe<Scalars['String']['output']>;
1194
1236
  /** The name of the integration. */
1195
1237
  name: Scalars['String']['output'];
1196
1238
  patchedAt?: Maybe<Scalars['DateTime']['output']>;
@@ -1251,11 +1293,13 @@ export type IntegrationState = typeof IntegrationState[keyof typeof IntegrationS
1251
1293
  * - BCWEBCHAT: BC Webchat integration.
1252
1294
  * - FACEBOOK: Facebook integration.
1253
1295
  * - INSTAGRAM: Instagram integration.
1296
+ * - TELEGRAM: Telegram integration.
1254
1297
  */
1255
1298
  export declare const IntegrationType: {
1256
1299
  readonly BCWEBCHAT: "BCWEBCHAT";
1257
1300
  readonly FACEBOOK: "FACEBOOK";
1258
1301
  readonly INSTAGRAM: "INSTAGRAM";
1302
+ readonly TELEGRAM: "TELEGRAM";
1259
1303
  readonly WHATSAPP: "WHATSAPP";
1260
1304
  };
1261
1305
  export type IntegrationType = typeof IntegrationType[keyof typeof IntegrationType];
@@ -1265,6 +1309,7 @@ export type IntegrationWithSecrets = {
1265
1309
  createdAt: Scalars['DateTime']['output'];
1266
1310
  deletedAt?: Maybe<Scalars['DateTime']['output']>;
1267
1311
  id: Scalars['ID']['output'];
1312
+ identifier?: Maybe<Scalars['String']['output']>;
1268
1313
  integrationProperties: Scalars['JSON']['output'];
1269
1314
  name: Scalars['String']['output'];
1270
1315
  patchedAt?: Maybe<Scalars['DateTime']['output']>;
@@ -1344,6 +1389,8 @@ export type Message = {
1344
1389
  createdAt: Scalars['DateTime']['output'];
1345
1390
  /** The external message id of the message. */
1346
1391
  externalMessageId?: Maybe<Scalars['String']['output']>;
1392
+ /** The reason why the message failed to be sent. */
1393
+ failedReason?: Maybe<Scalars['String']['output']>;
1347
1394
  /** Whether the message is from an agent or the client. */
1348
1395
  isAgent: Scalars['Boolean']['output'];
1349
1396
  /** The id of the message. */
@@ -1558,6 +1605,11 @@ export type Mutation = {
1558
1605
  assignConv: Conversation;
1559
1606
  assignOwner: UserRole;
1560
1607
  assignUserRole: UserRole;
1608
+ /**
1609
+ * Bulk soft delete clients by IDs. This archives clients by setting deletedAt.
1610
+ * You should have the MANAGE_CLIENTS permission to bulk delete clients.
1611
+ */
1612
+ bulkDeleteClients: BulkPermanentDeleteClientsResult;
1561
1613
  /** Bulk import contacts from a CSV file stored in blob storage. Returns a job ID to track progress. You should have the MANAGE_CLIENTS permission to bulk import contacts. */
1562
1614
  bulkImportContacts: BulkImportContactsResult;
1563
1615
  /** Bulk patch tags. You should have the MANAGE_WORKSPACE permission to bulk patch tags. */
@@ -1572,6 +1624,11 @@ export type Mutation = {
1572
1624
  * You should have the MANAGE_WORKSPACE permission to permanently delete clients.
1573
1625
  */
1574
1626
  bulkPermanentDeleteClientsByFilter: BulkPermanentDeleteClientsResult;
1627
+ /**
1628
+ * Bulk undelete clients by IDs. This restores archived clients by clearing deletedAt.
1629
+ * You should have the MANAGE_CLIENTS permission to bulk undelete clients.
1630
+ */
1631
+ bulkUndeleteClients: BulkPermanentDeleteClientsResult;
1575
1632
  /**
1576
1633
  * Cancel a scheduled broadcast that hasn't started yet (scheduled -> draft).
1577
1634
  * You should have the MANAGE_CONVS permission to cancel a broadcast.
@@ -1672,6 +1729,9 @@ export type MutationAssignOwnerArgs = {
1672
1729
  export type MutationAssignUserRoleArgs = {
1673
1730
  input: InputAssignUserRole;
1674
1731
  };
1732
+ export type MutationBulkDeleteClientsArgs = {
1733
+ input: BulkPermanentDeleteClientsInput;
1734
+ };
1675
1735
  export type MutationBulkImportContactsArgs = {
1676
1736
  input: BulkImportContactsInput;
1677
1737
  };
@@ -1684,6 +1744,9 @@ export type MutationBulkPermanentDeleteClientsArgs = {
1684
1744
  export type MutationBulkPermanentDeleteClientsByFilterArgs = {
1685
1745
  input: BulkPermanentDeleteClientsByFilterInput;
1686
1746
  };
1747
+ export type MutationBulkUndeleteClientsArgs = {
1748
+ input: BulkPermanentDeleteClientsInput;
1749
+ };
1687
1750
  export type MutationCancelBroadcastArgs = {
1688
1751
  input: BroadcastCancelInput;
1689
1752
  };
@@ -1894,6 +1957,8 @@ export type Query = {
1894
1957
  broadcastDeliveryReport: BroadcastDeliveryReport;
1895
1958
  /** Get broadcast message statuses with client information. You should have the MANAGE_CONVS permission to get broadcast message statuses. */
1896
1959
  broadcastMessageStatuses: BroadcastMessageStatusesPayload;
1960
+ /** Get broadcast usage reports broken down by hour. You should have the MANAGE_CONVS permission to get broadcast reports. */
1961
+ broadcastReport: BroadcastReportPayload;
1897
1962
  /** Get the count of broadcasts grouped by state. You should have the MANAGE_CONVS permission to get the counts. */
1898
1963
  broadcastStateCounts: Array<BroadcastStateCount>;
1899
1964
  /** Get the broadcasts. You should have the MANAGE_CONVS permission to get the broadcasts. */
@@ -1906,6 +1971,8 @@ export type Query = {
1906
1971
  clientByPhone: Client;
1907
1972
  /** Get the clients. You should have the MANAGE_CLIENTS permission to get the clients. */
1908
1973
  clients: ClientsPayload;
1974
+ /** Get the last message of a conversation if it is currently open. Returns null if the conversation is ended or not found. */
1975
+ convLastMessage?: Maybe<Message>;
1909
1976
  /** Get the conversations. If you don't have the MANAGE_CONVS permission, it will return only the conversations assigned to you. */
1910
1977
  convs: ConvsPayload;
1911
1978
  /** Get the conversations report. You should have the MANAGE_CONVS permission to get the conversations report. */
@@ -1979,6 +2046,9 @@ export type QueryBroadcastMessageStatusesArgs = {
1979
2046
  input: BroadcastMessageStatusesInput;
1980
2047
  pageInfo?: InputMaybe<PageInfoInput>;
1981
2048
  };
2049
+ export type QueryBroadcastReportArgs = {
2050
+ input: BroadcastReportInput;
2051
+ };
1982
2052
  export type QueryBroadcastStateCountsArgs = {
1983
2053
  input: BroadcastsInput;
1984
2054
  };
@@ -1999,6 +2069,9 @@ export type QueryClientsArgs = {
1999
2069
  input: ClientsInput;
2000
2070
  pageInfo?: InputMaybe<PageInfoInput>;
2001
2071
  };
2072
+ export type QueryConvLastMessageArgs = {
2073
+ input: ConvLastMessageInput;
2074
+ };
2002
2075
  export type QueryConvsArgs = {
2003
2076
  input: ConvsInput;
2004
2077
  pageInfo?: InputMaybe<PageInfoInput>;
@@ -2428,6 +2501,8 @@ export type Workspace = {
2428
2501
  /** WorkspaceSettings represents configuration options for a workspace. */
2429
2502
  export type WorkspaceSettings = {
2430
2503
  __typename?: 'WorkspaceSettings';
2504
+ /** When enabled, automatically unarchives a contact when receiving a message from them. */
2505
+ autoUnarchiveOnMessage?: Maybe<Scalars['Boolean']['output']>;
2431
2506
  /** The conversation Time-To-Live (TTL) in hours. Determines how long conversations are retained before closing it automatically. */
2432
2507
  convTTL?: Maybe<Scalars['Int']['output']>;
2433
2508
  /** The unique identifier of the workspace settings record. */
@@ -2446,6 +2521,8 @@ export type WorkspaceSettingsInput = {
2446
2521
  };
2447
2522
  /** Input for updating workspace settings. */
2448
2523
  export type WorkspaceSettingsPatchInput = {
2524
+ /** When enabled, automatically unarchives a contact when receiving a message from them. */
2525
+ autoUnarchiveOnMessage?: InputMaybe<Scalars['Boolean']['input']>;
2449
2526
  /** The conversation Time-To-Live (TTL) in hours. Determines how long conversations are retained before closing it automatically. */
2450
2527
  convTTL?: InputMaybe<Scalars['Int']['input']>;
2451
2528
  /** Keyword that, when sent by a contact in a message, triggers automatic archival of that contact. Set to null to disable. */
@@ -2816,25 +2893,6 @@ export type BroadcastFragment = {
2816
2893
  failedCount?: number | null;
2817
2894
  error?: string | null;
2818
2895
  };
2819
- export type ClientFragment = {
2820
- __typename?: 'Client';
2821
- workspaceId: number;
2822
- id: string;
2823
- email?: string | null;
2824
- name?: string | null;
2825
- surname?: string | null;
2826
- phone?: string | null;
2827
- address?: string | null;
2828
- code?: string | null;
2829
- city?: string | null;
2830
- country?: string | null;
2831
- externalClientId?: string | null;
2832
- tags?: Array<string> | null;
2833
- createdAt: any;
2834
- stageId?: string | null;
2835
- defaultAgentId?: string | null;
2836
- deletedAt?: any | null;
2837
- };
2838
2896
  export type ConversationFragment = {
2839
2897
  __typename?: 'Conversation';
2840
2898
  workspaceId: number;
@@ -2864,6 +2922,7 @@ export type ConversationFragment = {
2864
2922
  isAgent: boolean;
2865
2923
  agentId?: string | null;
2866
2924
  status?: MessageStatus | null;
2925
+ failedReason?: string | null;
2867
2926
  externalMessageId?: string | null;
2868
2927
  tags?: Array<string> | null;
2869
2928
  createdAt: any;
@@ -2898,6 +2957,7 @@ export type MessageFragment = {
2898
2957
  isAgent: boolean;
2899
2958
  agentId?: string | null;
2900
2959
  status?: MessageStatus | null;
2960
+ failedReason?: string | null;
2901
2961
  externalMessageId?: string | null;
2902
2962
  tags?: Array<string> | null;
2903
2963
  createdAt: any;
@@ -2950,6 +3010,7 @@ export type AddMessageMutation = {
2950
3010
  isAgent: boolean;
2951
3011
  agentId?: string | null;
2952
3012
  status?: MessageStatus | null;
3013
+ failedReason?: string | null;
2953
3014
  externalMessageId?: string | null;
2954
3015
  tags?: Array<string> | null;
2955
3016
  createdAt: any;
@@ -3039,6 +3100,7 @@ export type AssignConvMutation = {
3039
3100
  isAgent: boolean;
3040
3101
  agentId?: string | null;
3041
3102
  status?: MessageStatus | null;
3103
+ failedReason?: string | null;
3042
3104
  externalMessageId?: string | null;
3043
3105
  tags?: Array<string> | null;
3044
3106
  createdAt: any;
@@ -3115,6 +3177,7 @@ export type BroadcastDeliveryReportQuery = {
3115
3177
  isAgent: boolean;
3116
3178
  agentId?: string | null;
3117
3179
  status?: MessageStatus | null;
3180
+ failedReason?: string | null;
3118
3181
  externalMessageId?: string | null;
3119
3182
  tags?: Array<string> | null;
3120
3183
  createdAt: any;
@@ -3204,55 +3267,6 @@ export type BroadcastsQuery = {
3204
3267
  } | null;
3205
3268
  };
3206
3269
  };
3207
- export type BulkImportContactsMutationVariables = Exact<{
3208
- input: BulkImportContactsInput;
3209
- }>;
3210
- export type BulkImportContactsMutation = {
3211
- __typename?: 'Mutation';
3212
- bulkImportContacts: {
3213
- __typename?: 'BulkImportContactsResult';
3214
- jobId: string;
3215
- };
3216
- };
3217
- export type BulkImportContactsJobStatusQueryVariables = Exact<{
3218
- input: BulkImportContactsJobStatusInput;
3219
- }>;
3220
- export type BulkImportContactsJobStatusQuery = {
3221
- __typename?: 'Query';
3222
- bulkImportContactsJobStatus?: {
3223
- __typename?: 'BulkImportContactsJobStatus';
3224
- status: JobStatus;
3225
- startedAt?: any | null;
3226
- completedAt?: any | null;
3227
- error?: string | null;
3228
- processedCount?: number | null;
3229
- totalCount?: number | null;
3230
- totalProcessed?: number | null;
3231
- success?: number | null;
3232
- errors?: number | null;
3233
- skipped?: number | null;
3234
- } | null;
3235
- };
3236
- export type BulkPermanentDeleteClientsMutationVariables = Exact<{
3237
- input: BulkPermanentDeleteClientsInput;
3238
- }>;
3239
- export type BulkPermanentDeleteClientsMutation = {
3240
- __typename?: 'Mutation';
3241
- bulkPermanentDeleteClients: {
3242
- __typename?: 'BulkPermanentDeleteClientsResult';
3243
- deletedCount: number;
3244
- };
3245
- };
3246
- export type BulkPermanentDeleteClientsByFilterMutationVariables = Exact<{
3247
- input: BulkPermanentDeleteClientsByFilterInput;
3248
- }>;
3249
- export type BulkPermanentDeleteClientsByFilterMutation = {
3250
- __typename?: 'Mutation';
3251
- bulkPermanentDeleteClientsByFilter: {
3252
- __typename?: 'BulkPermanentDeleteClientsResult';
3253
- deletedCount: number;
3254
- };
3255
- };
3256
3270
  export type CancelBroadcastMutationVariables = Exact<{
3257
3271
  input: BroadcastCancelInput;
3258
3272
  }>;
@@ -3280,91 +3294,6 @@ export type CancelBroadcastMutation = {
3280
3294
  error?: string | null;
3281
3295
  };
3282
3296
  };
3283
- export type ClientQueryVariables = Exact<{
3284
- input: ClientInput;
3285
- }>;
3286
- export type ClientQuery = {
3287
- __typename?: 'Query';
3288
- client: {
3289
- __typename?: 'Client';
3290
- workspaceId: number;
3291
- id: string;
3292
- email?: string | null;
3293
- name?: string | null;
3294
- surname?: string | null;
3295
- phone?: string | null;
3296
- address?: string | null;
3297
- code?: string | null;
3298
- city?: string | null;
3299
- country?: string | null;
3300
- externalClientId?: string | null;
3301
- tags?: Array<string> | null;
3302
- createdAt: any;
3303
- stageId?: string | null;
3304
- defaultAgentId?: string | null;
3305
- deletedAt?: any | null;
3306
- };
3307
- };
3308
- export type ClientByPhoneQueryVariables = Exact<{
3309
- input: ClientByPhoneInput;
3310
- }>;
3311
- export type ClientByPhoneQuery = {
3312
- __typename?: 'Query';
3313
- clientByPhone: {
3314
- __typename?: 'Client';
3315
- workspaceId: number;
3316
- id: string;
3317
- email?: string | null;
3318
- name?: string | null;
3319
- surname?: string | null;
3320
- phone?: string | null;
3321
- address?: string | null;
3322
- code?: string | null;
3323
- city?: string | null;
3324
- country?: string | null;
3325
- externalClientId?: string | null;
3326
- tags?: Array<string> | null;
3327
- createdAt: any;
3328
- stageId?: string | null;
3329
- defaultAgentId?: string | null;
3330
- deletedAt?: any | null;
3331
- };
3332
- };
3333
- export type ClientsQueryVariables = Exact<{
3334
- input: ClientsInput;
3335
- pageInfo?: InputMaybe<PageInfoInput>;
3336
- }>;
3337
- export type ClientsQuery = {
3338
- __typename?: 'Query';
3339
- clients: {
3340
- __typename?: 'ClientsPayload';
3341
- nodes?: Array<{
3342
- __typename?: 'Client';
3343
- workspaceId: number;
3344
- id: string;
3345
- email?: string | null;
3346
- name?: string | null;
3347
- surname?: string | null;
3348
- phone?: string | null;
3349
- address?: string | null;
3350
- code?: string | null;
3351
- city?: string | null;
3352
- country?: string | null;
3353
- externalClientId?: string | null;
3354
- tags?: Array<string> | null;
3355
- createdAt: any;
3356
- stageId?: string | null;
3357
- defaultAgentId?: string | null;
3358
- deletedAt?: any | null;
3359
- }> | null;
3360
- pageInfo?: {
3361
- __typename?: 'PageInfo';
3362
- hasNextPage: boolean;
3363
- endCursor?: any | null;
3364
- count?: number | null;
3365
- } | null;
3366
- };
3367
- };
3368
3297
  export type ConvsQueryVariables = Exact<{
3369
3298
  input: ConvsInput;
3370
3299
  pageInfo?: InputMaybe<PageInfoInput>;
@@ -3402,6 +3331,7 @@ export type ConvsQuery = {
3402
3331
  isAgent: boolean;
3403
3332
  agentId?: string | null;
3404
3333
  status?: MessageStatus | null;
3334
+ failedReason?: string | null;
3405
3335
  externalMessageId?: string | null;
3406
3336
  tags?: Array<string> | null;
3407
3337
  createdAt: any;
@@ -3479,31 +3409,6 @@ export type CreateBroadcastMutation = {
3479
3409
  error?: string | null;
3480
3410
  };
3481
3411
  };
3482
- export type CreateClientMutationVariables = Exact<{
3483
- input: ClientCreateInput;
3484
- }>;
3485
- export type CreateClientMutation = {
3486
- __typename?: 'Mutation';
3487
- createClient: {
3488
- __typename?: 'Client';
3489
- workspaceId: number;
3490
- id: string;
3491
- email?: string | null;
3492
- name?: string | null;
3493
- surname?: string | null;
3494
- phone?: string | null;
3495
- address?: string | null;
3496
- code?: string | null;
3497
- city?: string | null;
3498
- country?: string | null;
3499
- externalClientId?: string | null;
3500
- tags?: Array<string> | null;
3501
- createdAt: any;
3502
- stageId?: string | null;
3503
- defaultAgentId?: string | null;
3504
- deletedAt?: any | null;
3505
- };
3506
- };
3507
3412
  export type DeleteAgentMutationVariables = Exact<{
3508
3413
  input: AgentInput;
3509
3414
  }>;
@@ -3548,56 +3453,6 @@ export type DeleteBroadcastMutation = {
3548
3453
  error?: string | null;
3549
3454
  };
3550
3455
  };
3551
- export type DeleteClientMutationVariables = Exact<{
3552
- input: ClientInput;
3553
- }>;
3554
- export type DeleteClientMutation = {
3555
- __typename?: 'Mutation';
3556
- deleteClient: {
3557
- __typename?: 'Client';
3558
- workspaceId: number;
3559
- id: string;
3560
- email?: string | null;
3561
- name?: string | null;
3562
- surname?: string | null;
3563
- phone?: string | null;
3564
- address?: string | null;
3565
- code?: string | null;
3566
- city?: string | null;
3567
- country?: string | null;
3568
- externalClientId?: string | null;
3569
- tags?: Array<string> | null;
3570
- createdAt: any;
3571
- stageId?: string | null;
3572
- defaultAgentId?: string | null;
3573
- deletedAt?: any | null;
3574
- };
3575
- };
3576
- export type DeleteClientByExternalIdMutationVariables = Exact<{
3577
- input: ClientDeleteByExternalIdInput;
3578
- }>;
3579
- export type DeleteClientByExternalIdMutation = {
3580
- __typename?: 'Mutation';
3581
- deleteClientByExternalId: {
3582
- __typename?: 'Client';
3583
- workspaceId: number;
3584
- id: string;
3585
- email?: string | null;
3586
- name?: string | null;
3587
- surname?: string | null;
3588
- phone?: string | null;
3589
- address?: string | null;
3590
- code?: string | null;
3591
- city?: string | null;
3592
- country?: string | null;
3593
- externalClientId?: string | null;
3594
- tags?: Array<string> | null;
3595
- createdAt: any;
3596
- stageId?: string | null;
3597
- defaultAgentId?: string | null;
3598
- deletedAt?: any | null;
3599
- };
3600
- };
3601
3456
  export type EndConvMutationVariables = Exact<{
3602
3457
  input: ConvEndInput;
3603
3458
  }>;
@@ -3632,6 +3487,7 @@ export type EndConvMutation = {
3632
3487
  isAgent: boolean;
3633
3488
  agentId?: string | null;
3634
3489
  status?: MessageStatus | null;
3490
+ failedReason?: string | null;
3635
3491
  externalMessageId?: string | null;
3636
3492
  tags?: Array<string> | null;
3637
3493
  createdAt: any;
@@ -3702,6 +3558,7 @@ export type MessagesQuery = {
3702
3558
  isAgent: boolean;
3703
3559
  agentId?: string | null;
3704
3560
  status?: MessageStatus | null;
3561
+ failedReason?: string | null;
3705
3562
  externalMessageId?: string | null;
3706
3563
  tags?: Array<string> | null;
3707
3564
  createdAt: any;
@@ -3771,31 +3628,6 @@ export type PatchBroadcastMutation = {
3771
3628
  error?: string | null;
3772
3629
  };
3773
3630
  };
3774
- export type PatchClientMutationVariables = Exact<{
3775
- input: ClientPatchInput;
3776
- }>;
3777
- export type PatchClientMutation = {
3778
- __typename?: 'Mutation';
3779
- patchClient: {
3780
- __typename?: 'Client';
3781
- workspaceId: number;
3782
- id: string;
3783
- email?: string | null;
3784
- name?: string | null;
3785
- surname?: string | null;
3786
- phone?: string | null;
3787
- address?: string | null;
3788
- code?: string | null;
3789
- city?: string | null;
3790
- country?: string | null;
3791
- externalClientId?: string | null;
3792
- tags?: Array<string> | null;
3793
- createdAt: any;
3794
- stageId?: string | null;
3795
- defaultAgentId?: string | null;
3796
- deletedAt?: any | null;
3797
- };
3798
- };
3799
3631
  export type PatchConvMutationVariables = Exact<{
3800
3632
  input: ConvPatchInput;
3801
3633
  }>;
@@ -3830,6 +3662,7 @@ export type PatchConvMutation = {
3830
3662
  isAgent: boolean;
3831
3663
  agentId?: string | null;
3832
3664
  status?: MessageStatus | null;
3665
+ failedReason?: string | null;
3833
3666
  externalMessageId?: string | null;
3834
3667
  tags?: Array<string> | null;
3835
3668
  createdAt: any;
@@ -3890,6 +3723,7 @@ export type StartConvMutation = {
3890
3723
  isAgent: boolean;
3891
3724
  agentId?: string | null;
3892
3725
  status?: MessageStatus | null;
3726
+ failedReason?: string | null;
3893
3727
  externalMessageId?: string | null;
3894
3728
  tags?: Array<string> | null;
3895
3729
  createdAt: any;
@@ -3939,6 +3773,7 @@ export type TagClientMutation = {
3939
3773
  stageId?: string | null;
3940
3774
  defaultAgentId?: string | null;
3941
3775
  deletedAt?: any | null;
3776
+ archivedBy?: string | null;
3942
3777
  };
3943
3778
  };
3944
3779
  export type TagConvMutationVariables = Exact<{
@@ -3975,6 +3810,7 @@ export type TagConvMutation = {
3975
3810
  isAgent: boolean;
3976
3811
  agentId?: string | null;
3977
3812
  status?: MessageStatus | null;
3813
+ failedReason?: string | null;
3978
3814
  externalMessageId?: string | null;
3979
3815
  tags?: Array<string> | null;
3980
3816
  createdAt: any;
@@ -4017,56 +3853,6 @@ export type TagsQuery = {
4017
3853
  }> | null;
4018
3854
  };
4019
3855
  };
4020
- export type UndeleteClientMutationVariables = Exact<{
4021
- input: ClientInput;
4022
- }>;
4023
- export type UndeleteClientMutation = {
4024
- __typename?: 'Mutation';
4025
- undeleteClient: {
4026
- __typename?: 'Client';
4027
- workspaceId: number;
4028
- id: string;
4029
- email?: string | null;
4030
- name?: string | null;
4031
- surname?: string | null;
4032
- phone?: string | null;
4033
- address?: string | null;
4034
- code?: string | null;
4035
- city?: string | null;
4036
- country?: string | null;
4037
- externalClientId?: string | null;
4038
- tags?: Array<string> | null;
4039
- createdAt: any;
4040
- stageId?: string | null;
4041
- defaultAgentId?: string | null;
4042
- deletedAt?: any | null;
4043
- };
4044
- };
4045
- export type UndeleteClientByExternalIdMutationVariables = Exact<{
4046
- input: ClientDeleteByExternalIdInput;
4047
- }>;
4048
- export type UndeleteClientByExternalIdMutation = {
4049
- __typename?: 'Mutation';
4050
- undeleteClientByExternalId: {
4051
- __typename?: 'Client';
4052
- workspaceId: number;
4053
- id: string;
4054
- email?: string | null;
4055
- name?: string | null;
4056
- surname?: string | null;
4057
- phone?: string | null;
4058
- address?: string | null;
4059
- code?: string | null;
4060
- city?: string | null;
4061
- country?: string | null;
4062
- externalClientId?: string | null;
4063
- tags?: Array<string> | null;
4064
- createdAt: any;
4065
- stageId?: string | null;
4066
- defaultAgentId?: string | null;
4067
- deletedAt?: any | null;
4068
- };
4069
- };
4070
3856
  export type UntagClientMutationVariables = Exact<{
4071
3857
  input: ClientTagInput;
4072
3858
  }>;
@@ -4090,6 +3876,7 @@ export type UntagClientMutation = {
4090
3876
  stageId?: string | null;
4091
3877
  defaultAgentId?: string | null;
4092
3878
  deletedAt?: any | null;
3879
+ archivedBy?: string | null;
4093
3880
  };
4094
3881
  };
4095
3882
  export type UntagConvMutationVariables = Exact<{
@@ -4126,6 +3913,7 @@ export type UntagConvMutation = {
4126
3913
  isAgent: boolean;
4127
3914
  agentId?: string | null;
4128
3915
  status?: MessageStatus | null;
3916
+ failedReason?: string | null;
4129
3917
  externalMessageId?: string | null;
4130
3918
  tags?: Array<string> | null;
4131
3919
  createdAt: any;
@@ -4152,23 +3940,6 @@ export type UntagConvMutation = {
4152
3940
  } | null> | null;
4153
3941
  };
4154
3942
  };
4155
- export type ValidateBulkImportContactsQueryVariables = Exact<{
4156
- input: ValidateBulkImportContactsInput;
4157
- }>;
4158
- export type ValidateBulkImportContactsQuery = {
4159
- __typename?: 'Query';
4160
- validateBulkImportContacts: {
4161
- __typename?: 'ValidateBulkImportContactsResult';
4162
- totalRows: number;
4163
- validRows: number;
4164
- invalidRows: number;
4165
- errors: Array<{
4166
- __typename?: 'ValidationError';
4167
- row: number;
4168
- message: string;
4169
- }>;
4170
- };
4171
- };
4172
3943
  export type WabaMessageTemplateDetailsQueryVariables = Exact<{
4173
3944
  input: WabaMessageTemplateDetailsInput;
4174
3945
  }>;
@@ -4205,137 +3976,520 @@ export type WabaMessageTemplatesQuery = {
4205
3976
  }> | null;
4206
3977
  };
4207
3978
  };
4208
- export type AiFragment = {
4209
- __typename?: 'AI';
4210
- workspaceId: number;
4211
- id: string;
4212
- name: string;
4213
- type: AiType;
4214
- createdAt: any;
4215
- deletedAt?: any | null;
4216
- integrationProperties?: {
4217
- __typename?: 'IntegrationProperties';
4218
- model?: string | null;
4219
- version?: string | null;
4220
- } | null;
4221
- };
4222
- export type ApiKeyFragment = {
4223
- __typename?: 'ApiKey';
4224
- workspaceId: number;
4225
- id: string;
4226
- key: string;
4227
- label: string;
4228
- createdAt: any;
4229
- };
4230
- export type IntegrationFragment = {
4231
- __typename?: 'Integration';
3979
+ export type ClientFragment = {
3980
+ __typename?: 'Client';
4232
3981
  workspaceId: number;
4233
3982
  id: string;
4234
- name: string;
4235
- type: IntegrationType;
4236
- properties?: any | null;
4237
- state: IntegrationState;
3983
+ email?: string | null;
3984
+ name?: string | null;
3985
+ surname?: string | null;
3986
+ phone?: string | null;
3987
+ address?: string | null;
3988
+ code?: string | null;
3989
+ city?: string | null;
3990
+ country?: string | null;
3991
+ externalClientId?: string | null;
3992
+ tags?: Array<string> | null;
4238
3993
  createdAt: any;
3994
+ stageId?: string | null;
3995
+ defaultAgentId?: string | null;
4239
3996
  deletedAt?: any | null;
4240
- patchedAt?: any | null;
4241
- };
4242
- export type WebhookFragment = {
4243
- __typename?: 'Webhook';
4244
- workspaceId: number;
4245
- id: string;
4246
- label: string;
4247
- url: string;
4248
- event: WebhookEvent;
4249
- createdAt: any;
3997
+ archivedBy?: string | null;
4250
3998
  };
4251
- export type AiQueryVariables = Exact<{
4252
- input: AiInput;
3999
+ export type BulkDeleteClientsMutationVariables = Exact<{
4000
+ input: BulkPermanentDeleteClientsInput;
4253
4001
  }>;
4254
- export type AiQuery = {
4255
- __typename?: 'Query';
4256
- ai: {
4257
- __typename?: 'AI';
4258
- workspaceId: number;
4259
- id: string;
4260
- name: string;
4261
- type: AiType;
4262
- createdAt: any;
4263
- deletedAt?: any | null;
4264
- integrationProperties?: {
4265
- __typename?: 'IntegrationProperties';
4266
- model?: string | null;
4267
- version?: string | null;
4268
- } | null;
4002
+ export type BulkDeleteClientsMutation = {
4003
+ __typename?: 'Mutation';
4004
+ bulkDeleteClients: {
4005
+ __typename?: 'BulkPermanentDeleteClientsResult';
4006
+ deletedCount: number;
4269
4007
  };
4270
4008
  };
4271
- export type AisQueryVariables = Exact<{
4272
- input: AIsInput;
4009
+ export type BulkImportContactsMutationVariables = Exact<{
4010
+ input: BulkImportContactsInput;
4273
4011
  }>;
4274
- export type AisQuery = {
4275
- __typename?: 'Query';
4276
- ais: {
4277
- __typename?: 'AIsPayload';
4278
- nodes?: Array<{
4279
- __typename?: 'AI';
4280
- workspaceId: number;
4281
- id: string;
4282
- name: string;
4283
- type: AiType;
4284
- createdAt: any;
4285
- deletedAt?: any | null;
4286
- integrationProperties?: {
4287
- __typename?: 'IntegrationProperties';
4288
- model?: string | null;
4289
- version?: string | null;
4290
- } | null;
4291
- }> | null;
4012
+ export type BulkImportContactsMutation = {
4013
+ __typename?: 'Mutation';
4014
+ bulkImportContacts: {
4015
+ __typename?: 'BulkImportContactsResult';
4016
+ jobId: string;
4292
4017
  };
4293
4018
  };
4294
- export type ApiKeysQueryVariables = Exact<{
4295
- input: ApiKeysInput;
4019
+ export type BulkImportContactsJobStatusQueryVariables = Exact<{
4020
+ input: BulkImportContactsJobStatusInput;
4296
4021
  }>;
4297
- export type ApiKeysQuery = {
4022
+ export type BulkImportContactsJobStatusQuery = {
4298
4023
  __typename?: 'Query';
4299
- apiKeys: {
4300
- __typename?: 'ApiKeysPayload';
4301
- nodes?: Array<{
4302
- __typename?: 'ApiKey';
4303
- workspaceId: number;
4304
- id: string;
4305
- key: string;
4306
- label: string;
4307
- createdAt: any;
4308
- }> | null;
4309
- };
4024
+ bulkImportContactsJobStatus?: {
4025
+ __typename?: 'BulkImportContactsJobStatus';
4026
+ status: JobStatus;
4027
+ startedAt?: any | null;
4028
+ completedAt?: any | null;
4029
+ error?: string | null;
4030
+ processedCount?: number | null;
4031
+ totalCount?: number | null;
4032
+ totalProcessed?: number | null;
4033
+ success?: number | null;
4034
+ errors?: number | null;
4035
+ skipped?: number | null;
4036
+ } | null;
4310
4037
  };
4311
- export type BulkPatchTagsMutationVariables = Exact<{
4312
- input: TagBulkPatchInput;
4038
+ export type BulkPermanentDeleteClientsMutationVariables = Exact<{
4039
+ input: BulkPermanentDeleteClientsInput;
4313
4040
  }>;
4314
- export type BulkPatchTagsMutation = {
4041
+ export type BulkPermanentDeleteClientsMutation = {
4315
4042
  __typename?: 'Mutation';
4316
- bulkPatchTags: never;
4043
+ bulkPermanentDeleteClients: {
4044
+ __typename?: 'BulkPermanentDeleteClientsResult';
4045
+ deletedCount: number;
4046
+ };
4317
4047
  };
4318
- export type CreateAiMutationVariables = Exact<{
4319
- input: AiCreateInput;
4048
+ export type BulkPermanentDeleteClientsByFilterMutationVariables = Exact<{
4049
+ input: BulkPermanentDeleteClientsByFilterInput;
4320
4050
  }>;
4321
- export type CreateAiMutation = {
4051
+ export type BulkPermanentDeleteClientsByFilterMutation = {
4322
4052
  __typename?: 'Mutation';
4323
- createAi: {
4324
- __typename?: 'AI';
4325
- workspaceId: number;
4326
- id: string;
4327
- name: string;
4328
- type: AiType;
4329
- createdAt: any;
4330
- deletedAt?: any | null;
4331
- integrationProperties?: {
4332
- __typename?: 'IntegrationProperties';
4333
- model?: string | null;
4334
- version?: string | null;
4335
- } | null;
4053
+ bulkPermanentDeleteClientsByFilter: {
4054
+ __typename?: 'BulkPermanentDeleteClientsResult';
4055
+ deletedCount: number;
4336
4056
  };
4337
4057
  };
4338
- export type CreateIntegrationMutationVariables = Exact<{
4058
+ export type BulkUndeleteClientsMutationVariables = Exact<{
4059
+ input: BulkPermanentDeleteClientsInput;
4060
+ }>;
4061
+ export type BulkUndeleteClientsMutation = {
4062
+ __typename?: 'Mutation';
4063
+ bulkUndeleteClients: {
4064
+ __typename?: 'BulkPermanentDeleteClientsResult';
4065
+ deletedCount: number;
4066
+ };
4067
+ };
4068
+ export type ClientQueryVariables = Exact<{
4069
+ input: ClientInput;
4070
+ }>;
4071
+ export type ClientQuery = {
4072
+ __typename?: 'Query';
4073
+ client: {
4074
+ __typename?: 'Client';
4075
+ workspaceId: number;
4076
+ id: string;
4077
+ email?: string | null;
4078
+ name?: string | null;
4079
+ surname?: string | null;
4080
+ phone?: string | null;
4081
+ address?: string | null;
4082
+ code?: string | null;
4083
+ city?: string | null;
4084
+ country?: string | null;
4085
+ externalClientId?: string | null;
4086
+ tags?: Array<string> | null;
4087
+ createdAt: any;
4088
+ stageId?: string | null;
4089
+ defaultAgentId?: string | null;
4090
+ deletedAt?: any | null;
4091
+ archivedBy?: string | null;
4092
+ };
4093
+ };
4094
+ export type ClientByPhoneQueryVariables = Exact<{
4095
+ input: ClientByPhoneInput;
4096
+ }>;
4097
+ export type ClientByPhoneQuery = {
4098
+ __typename?: 'Query';
4099
+ clientByPhone: {
4100
+ __typename?: 'Client';
4101
+ workspaceId: number;
4102
+ id: string;
4103
+ email?: string | null;
4104
+ name?: string | null;
4105
+ surname?: string | null;
4106
+ phone?: string | null;
4107
+ address?: string | null;
4108
+ code?: string | null;
4109
+ city?: string | null;
4110
+ country?: string | null;
4111
+ externalClientId?: string | null;
4112
+ tags?: Array<string> | null;
4113
+ createdAt: any;
4114
+ stageId?: string | null;
4115
+ defaultAgentId?: string | null;
4116
+ deletedAt?: any | null;
4117
+ archivedBy?: string | null;
4118
+ };
4119
+ };
4120
+ export type ClientsQueryVariables = Exact<{
4121
+ input: ClientsInput;
4122
+ pageInfo?: InputMaybe<PageInfoInput>;
4123
+ }>;
4124
+ export type ClientsQuery = {
4125
+ __typename?: 'Query';
4126
+ clients: {
4127
+ __typename?: 'ClientsPayload';
4128
+ nodes?: Array<{
4129
+ __typename?: 'Client';
4130
+ workspaceId: number;
4131
+ id: string;
4132
+ email?: string | null;
4133
+ name?: string | null;
4134
+ surname?: string | null;
4135
+ phone?: string | null;
4136
+ address?: string | null;
4137
+ code?: string | null;
4138
+ city?: string | null;
4139
+ country?: string | null;
4140
+ externalClientId?: string | null;
4141
+ tags?: Array<string> | null;
4142
+ createdAt: any;
4143
+ stageId?: string | null;
4144
+ defaultAgentId?: string | null;
4145
+ deletedAt?: any | null;
4146
+ archivedBy?: string | null;
4147
+ }> | null;
4148
+ pageInfo?: {
4149
+ __typename?: 'PageInfo';
4150
+ hasNextPage: boolean;
4151
+ endCursor?: any | null;
4152
+ count?: number | null;
4153
+ } | null;
4154
+ };
4155
+ };
4156
+ export type CreateClientMutationVariables = Exact<{
4157
+ input: ClientCreateInput;
4158
+ }>;
4159
+ export type CreateClientMutation = {
4160
+ __typename?: 'Mutation';
4161
+ createClient: {
4162
+ __typename?: 'Client';
4163
+ workspaceId: number;
4164
+ id: string;
4165
+ email?: string | null;
4166
+ name?: string | null;
4167
+ surname?: string | null;
4168
+ phone?: string | null;
4169
+ address?: string | null;
4170
+ code?: string | null;
4171
+ city?: string | null;
4172
+ country?: string | null;
4173
+ externalClientId?: string | null;
4174
+ tags?: Array<string> | null;
4175
+ createdAt: any;
4176
+ stageId?: string | null;
4177
+ defaultAgentId?: string | null;
4178
+ deletedAt?: any | null;
4179
+ archivedBy?: string | null;
4180
+ };
4181
+ };
4182
+ export type DeleteClientMutationVariables = Exact<{
4183
+ input: ClientInput;
4184
+ }>;
4185
+ export type DeleteClientMutation = {
4186
+ __typename?: 'Mutation';
4187
+ deleteClient: {
4188
+ __typename?: 'Client';
4189
+ workspaceId: number;
4190
+ id: string;
4191
+ email?: string | null;
4192
+ name?: string | null;
4193
+ surname?: string | null;
4194
+ phone?: string | null;
4195
+ address?: string | null;
4196
+ code?: string | null;
4197
+ city?: string | null;
4198
+ country?: string | null;
4199
+ externalClientId?: string | null;
4200
+ tags?: Array<string> | null;
4201
+ createdAt: any;
4202
+ stageId?: string | null;
4203
+ defaultAgentId?: string | null;
4204
+ deletedAt?: any | null;
4205
+ archivedBy?: string | null;
4206
+ };
4207
+ };
4208
+ export type DeleteClientByExternalIdMutationVariables = Exact<{
4209
+ input: ClientDeleteByExternalIdInput;
4210
+ }>;
4211
+ export type DeleteClientByExternalIdMutation = {
4212
+ __typename?: 'Mutation';
4213
+ deleteClientByExternalId: {
4214
+ __typename?: 'Client';
4215
+ workspaceId: number;
4216
+ id: string;
4217
+ email?: string | null;
4218
+ name?: string | null;
4219
+ surname?: string | null;
4220
+ phone?: string | null;
4221
+ address?: string | null;
4222
+ code?: string | null;
4223
+ city?: string | null;
4224
+ country?: string | null;
4225
+ externalClientId?: string | null;
4226
+ tags?: Array<string> | null;
4227
+ createdAt: any;
4228
+ stageId?: string | null;
4229
+ defaultAgentId?: string | null;
4230
+ deletedAt?: any | null;
4231
+ archivedBy?: string | null;
4232
+ };
4233
+ };
4234
+ export type PatchClientMutationVariables = Exact<{
4235
+ input: ClientPatchInput;
4236
+ }>;
4237
+ export type PatchClientMutation = {
4238
+ __typename?: 'Mutation';
4239
+ patchClient: {
4240
+ __typename?: 'Client';
4241
+ workspaceId: number;
4242
+ id: string;
4243
+ email?: string | null;
4244
+ name?: string | null;
4245
+ surname?: string | null;
4246
+ phone?: string | null;
4247
+ address?: string | null;
4248
+ code?: string | null;
4249
+ city?: string | null;
4250
+ country?: string | null;
4251
+ externalClientId?: string | null;
4252
+ tags?: Array<string> | null;
4253
+ createdAt: any;
4254
+ stageId?: string | null;
4255
+ defaultAgentId?: string | null;
4256
+ deletedAt?: any | null;
4257
+ archivedBy?: string | null;
4258
+ };
4259
+ };
4260
+ export type UndeleteClientMutationVariables = Exact<{
4261
+ input: ClientInput;
4262
+ }>;
4263
+ export type UndeleteClientMutation = {
4264
+ __typename?: 'Mutation';
4265
+ undeleteClient: {
4266
+ __typename?: 'Client';
4267
+ workspaceId: number;
4268
+ id: string;
4269
+ email?: string | null;
4270
+ name?: string | null;
4271
+ surname?: string | null;
4272
+ phone?: string | null;
4273
+ address?: string | null;
4274
+ code?: string | null;
4275
+ city?: string | null;
4276
+ country?: string | null;
4277
+ externalClientId?: string | null;
4278
+ tags?: Array<string> | null;
4279
+ createdAt: any;
4280
+ stageId?: string | null;
4281
+ defaultAgentId?: string | null;
4282
+ deletedAt?: any | null;
4283
+ archivedBy?: string | null;
4284
+ };
4285
+ };
4286
+ export type UndeleteClientByExternalIdMutationVariables = Exact<{
4287
+ input: ClientDeleteByExternalIdInput;
4288
+ }>;
4289
+ export type UndeleteClientByExternalIdMutation = {
4290
+ __typename?: 'Mutation';
4291
+ undeleteClientByExternalId: {
4292
+ __typename?: 'Client';
4293
+ workspaceId: number;
4294
+ id: string;
4295
+ email?: string | null;
4296
+ name?: string | null;
4297
+ surname?: string | null;
4298
+ phone?: string | null;
4299
+ address?: string | null;
4300
+ code?: string | null;
4301
+ city?: string | null;
4302
+ country?: string | null;
4303
+ externalClientId?: string | null;
4304
+ tags?: Array<string> | null;
4305
+ createdAt: any;
4306
+ stageId?: string | null;
4307
+ defaultAgentId?: string | null;
4308
+ deletedAt?: any | null;
4309
+ archivedBy?: string | null;
4310
+ };
4311
+ };
4312
+ export type ValidateBulkImportContactsQueryVariables = Exact<{
4313
+ input: ValidateBulkImportContactsInput;
4314
+ }>;
4315
+ export type ValidateBulkImportContactsQuery = {
4316
+ __typename?: 'Query';
4317
+ validateBulkImportContacts: {
4318
+ __typename?: 'ValidateBulkImportContactsResult';
4319
+ totalRows: number;
4320
+ validRows: number;
4321
+ invalidRows: number;
4322
+ errors: Array<{
4323
+ __typename?: 'ValidationError';
4324
+ row: number;
4325
+ message: string;
4326
+ }>;
4327
+ };
4328
+ };
4329
+ export type AiFragment = {
4330
+ __typename?: 'AI';
4331
+ workspaceId: number;
4332
+ id: string;
4333
+ name: string;
4334
+ type: AiType;
4335
+ createdAt: any;
4336
+ deletedAt?: any | null;
4337
+ integrationProperties?: {
4338
+ __typename?: 'IntegrationProperties';
4339
+ model?: string | null;
4340
+ version?: string | null;
4341
+ } | null;
4342
+ configuration?: {
4343
+ __typename?: 'Configurations';
4344
+ askForName?: boolean | null;
4345
+ askForSurname?: boolean | null;
4346
+ askForEmail?: boolean | null;
4347
+ askForCity?: boolean | null;
4348
+ askForAddress?: boolean | null;
4349
+ } | null;
4350
+ };
4351
+ export type ApiKeyFragment = {
4352
+ __typename?: 'ApiKey';
4353
+ workspaceId: number;
4354
+ id: string;
4355
+ key: string;
4356
+ label: string;
4357
+ createdAt: any;
4358
+ };
4359
+ export type IntegrationFragment = {
4360
+ __typename?: 'Integration';
4361
+ workspaceId: number;
4362
+ id: string;
4363
+ name: string;
4364
+ identifier?: string | null;
4365
+ type: IntegrationType;
4366
+ properties?: any | null;
4367
+ state: IntegrationState;
4368
+ createdAt: any;
4369
+ deletedAt?: any | null;
4370
+ patchedAt?: any | null;
4371
+ };
4372
+ export type WebhookFragment = {
4373
+ __typename?: 'Webhook';
4374
+ workspaceId: number;
4375
+ id: string;
4376
+ label: string;
4377
+ url: string;
4378
+ event: WebhookEvent;
4379
+ createdAt: any;
4380
+ };
4381
+ export type AiQueryVariables = Exact<{
4382
+ input: AiInput;
4383
+ }>;
4384
+ export type AiQuery = {
4385
+ __typename?: 'Query';
4386
+ ai: {
4387
+ __typename?: 'AI';
4388
+ workspaceId: number;
4389
+ id: string;
4390
+ name: string;
4391
+ type: AiType;
4392
+ createdAt: any;
4393
+ deletedAt?: any | null;
4394
+ integrationProperties?: {
4395
+ __typename?: 'IntegrationProperties';
4396
+ model?: string | null;
4397
+ version?: string | null;
4398
+ } | null;
4399
+ configuration?: {
4400
+ __typename?: 'Configurations';
4401
+ askForName?: boolean | null;
4402
+ askForSurname?: boolean | null;
4403
+ askForEmail?: boolean | null;
4404
+ askForCity?: boolean | null;
4405
+ askForAddress?: boolean | null;
4406
+ } | null;
4407
+ };
4408
+ };
4409
+ export type AisQueryVariables = Exact<{
4410
+ input: AIsInput;
4411
+ }>;
4412
+ export type AisQuery = {
4413
+ __typename?: 'Query';
4414
+ ais: {
4415
+ __typename?: 'AIsPayload';
4416
+ nodes?: Array<{
4417
+ __typename?: 'AI';
4418
+ workspaceId: number;
4419
+ id: string;
4420
+ name: string;
4421
+ type: AiType;
4422
+ createdAt: any;
4423
+ deletedAt?: any | null;
4424
+ integrationProperties?: {
4425
+ __typename?: 'IntegrationProperties';
4426
+ model?: string | null;
4427
+ version?: string | null;
4428
+ } | null;
4429
+ configuration?: {
4430
+ __typename?: 'Configurations';
4431
+ askForName?: boolean | null;
4432
+ askForSurname?: boolean | null;
4433
+ askForEmail?: boolean | null;
4434
+ askForCity?: boolean | null;
4435
+ askForAddress?: boolean | null;
4436
+ } | null;
4437
+ }> | null;
4438
+ };
4439
+ };
4440
+ export type ApiKeysQueryVariables = Exact<{
4441
+ input: ApiKeysInput;
4442
+ }>;
4443
+ export type ApiKeysQuery = {
4444
+ __typename?: 'Query';
4445
+ apiKeys: {
4446
+ __typename?: 'ApiKeysPayload';
4447
+ nodes?: Array<{
4448
+ __typename?: 'ApiKey';
4449
+ workspaceId: number;
4450
+ id: string;
4451
+ key: string;
4452
+ label: string;
4453
+ createdAt: any;
4454
+ }> | null;
4455
+ };
4456
+ };
4457
+ export type BulkPatchTagsMutationVariables = Exact<{
4458
+ input: TagBulkPatchInput;
4459
+ }>;
4460
+ export type BulkPatchTagsMutation = {
4461
+ __typename?: 'Mutation';
4462
+ bulkPatchTags: never;
4463
+ };
4464
+ export type CreateAiMutationVariables = Exact<{
4465
+ input: AiCreateInput;
4466
+ }>;
4467
+ export type CreateAiMutation = {
4468
+ __typename?: 'Mutation';
4469
+ createAi: {
4470
+ __typename?: 'AI';
4471
+ workspaceId: number;
4472
+ id: string;
4473
+ name: string;
4474
+ type: AiType;
4475
+ createdAt: any;
4476
+ deletedAt?: any | null;
4477
+ integrationProperties?: {
4478
+ __typename?: 'IntegrationProperties';
4479
+ model?: string | null;
4480
+ version?: string | null;
4481
+ } | null;
4482
+ configuration?: {
4483
+ __typename?: 'Configurations';
4484
+ askForName?: boolean | null;
4485
+ askForSurname?: boolean | null;
4486
+ askForEmail?: boolean | null;
4487
+ askForCity?: boolean | null;
4488
+ askForAddress?: boolean | null;
4489
+ } | null;
4490
+ };
4491
+ };
4492
+ export type CreateIntegrationMutationVariables = Exact<{
4339
4493
  input: IntegrationCreateInput;
4340
4494
  }>;
4341
4495
  export type CreateIntegrationMutation = {
@@ -4345,6 +4499,7 @@ export type CreateIntegrationMutation = {
4345
4499
  workspaceId: number;
4346
4500
  id: string;
4347
4501
  name: string;
4502
+ identifier?: string | null;
4348
4503
  type: IntegrationType;
4349
4504
  properties?: any | null;
4350
4505
  state: IntegrationState;
@@ -4399,6 +4554,14 @@ export type DeleteAiMutation = {
4399
4554
  model?: string | null;
4400
4555
  version?: string | null;
4401
4556
  } | null;
4557
+ configuration?: {
4558
+ __typename?: 'Configurations';
4559
+ askForName?: boolean | null;
4560
+ askForSurname?: boolean | null;
4561
+ askForEmail?: boolean | null;
4562
+ askForCity?: boolean | null;
4563
+ askForAddress?: boolean | null;
4564
+ } | null;
4402
4565
  };
4403
4566
  };
4404
4567
  export type DeleteApiKeyMutationVariables = Exact<{
@@ -4425,6 +4588,7 @@ export type DeleteIntegrationMutation = {
4425
4588
  workspaceId: number;
4426
4589
  id: string;
4427
4590
  name: string;
4591
+ identifier?: string | null;
4428
4592
  type: IntegrationType;
4429
4593
  properties?: any | null;
4430
4594
  state: IntegrationState;
@@ -4485,6 +4649,7 @@ export type IntegrationQuery = {
4485
4649
  workspaceId: number;
4486
4650
  id: string;
4487
4651
  name: string;
4652
+ identifier?: string | null;
4488
4653
  type: IntegrationType;
4489
4654
  properties?: any | null;
4490
4655
  state: IntegrationState;
@@ -4505,6 +4670,7 @@ export type IntegrationsQuery = {
4505
4670
  workspaceId: number;
4506
4671
  id: string;
4507
4672
  name: string;
4673
+ identifier?: string | null;
4508
4674
  type: IntegrationType;
4509
4675
  properties?: any | null;
4510
4676
  state: IntegrationState;
@@ -4532,6 +4698,14 @@ export type PatchAiMutation = {
4532
4698
  model?: string | null;
4533
4699
  version?: string | null;
4534
4700
  } | null;
4701
+ configuration?: {
4702
+ __typename?: 'Configurations';
4703
+ askForName?: boolean | null;
4704
+ askForSurname?: boolean | null;
4705
+ askForEmail?: boolean | null;
4706
+ askForCity?: boolean | null;
4707
+ askForAddress?: boolean | null;
4708
+ } | null;
4535
4709
  };
4536
4710
  };
4537
4711
  export type PatchIntegrationMutationVariables = Exact<{
@@ -4544,6 +4718,7 @@ export type PatchIntegrationMutation = {
4544
4718
  workspaceId: number;
4545
4719
  id: string;
4546
4720
  name: string;
4721
+ identifier?: string | null;
4547
4722
  type: IntegrationType;
4548
4723
  properties?: any | null;
4549
4724
  state: IntegrationState;
@@ -4595,6 +4770,7 @@ export type WorkspaceSettingsFragment = {
4595
4770
  workspaceId: number;
4596
4771
  convTTL?: number | null;
4597
4772
  optOutKeyword?: string | null;
4773
+ autoUnarchiveOnMessage?: boolean | null;
4598
4774
  testNums?: Array<{
4599
4775
  __typename?: 'WorkspaceTestNumber';
4600
4776
  phone: string;
@@ -4619,6 +4795,7 @@ export type PatchWorkspaceSettingsMutation = {
4619
4795
  workspaceId: number;
4620
4796
  convTTL?: number | null;
4621
4797
  optOutKeyword?: string | null;
4798
+ autoUnarchiveOnMessage?: boolean | null;
4622
4799
  testNums?: Array<{
4623
4800
  __typename?: 'WorkspaceTestNumber';
4624
4801
  phone: string;
@@ -4637,6 +4814,7 @@ export type WorkspaceSettingsQuery = {
4637
4814
  workspaceId: number;
4638
4815
  convTTL?: number | null;
4639
4816
  optOutKeyword?: string | null;
4817
+ autoUnarchiveOnMessage?: boolean | null;
4640
4818
  testNums?: Array<{
4641
4819
  __typename?: 'WorkspaceTestNumber';
4642
4820
  phone: string;
@@ -4686,12 +4864,12 @@ export declare const ConversationReportFragmentDoc: Apollo.DocumentNode;
4686
4864
  export declare const PageInfoFragmentDoc: Apollo.DocumentNode;
4687
4865
  export declare const AgentFragmentDoc: Apollo.DocumentNode;
4688
4866
  export declare const BroadcastFragmentDoc: Apollo.DocumentNode;
4689
- export declare const ClientFragmentDoc: Apollo.DocumentNode;
4690
4867
  export declare const MessageFragmentDoc: Apollo.DocumentNode;
4691
4868
  export declare const ConversationFragmentDoc: Apollo.DocumentNode;
4692
4869
  export declare const TagFragmentDoc: Apollo.DocumentNode;
4693
4870
  export declare const MessageTemplateDetailsFragmentDoc: Apollo.DocumentNode;
4694
4871
  export declare const MessageTemplateFragmentDoc: Apollo.DocumentNode;
4872
+ export declare const ClientFragmentDoc: Apollo.DocumentNode;
4695
4873
  export declare const AiFragmentDoc: Apollo.DocumentNode;
4696
4874
  export declare const ApiKeyFragmentDoc: Apollo.DocumentNode;
4697
4875
  export declare const IntegrationFragmentDoc: Apollo.DocumentNode;
@@ -5543,849 +5721,1031 @@ export declare function refetchBroadcastsQuery(variables: BroadcastsQueryVariabl
5543
5721
  pageInfo?: InputMaybe<PageInfoInput> | undefined;
5544
5722
  }>;
5545
5723
  };
5546
- export declare const BulkImportContactsDocument: Apollo.DocumentNode;
5547
- export type BulkImportContactsMutationFn = Apollo.MutationFunction<BulkImportContactsMutation, BulkImportContactsMutationVariables>;
5724
+ export declare const CancelBroadcastDocument: Apollo.DocumentNode;
5725
+ export type CancelBroadcastMutationFn = Apollo.MutationFunction<CancelBroadcastMutation, CancelBroadcastMutationVariables>;
5548
5726
  /**
5549
- * __useBulkImportContactsMutation__
5727
+ * __useCancelBroadcastMutation__
5550
5728
  *
5551
- * To run a mutation, you first call `useBulkImportContactsMutation` within a React component and pass it any options that fit your needs.
5552
- * When your component renders, `useBulkImportContactsMutation` returns a tuple that includes:
5729
+ * To run a mutation, you first call `useCancelBroadcastMutation` within a React component and pass it any options that fit your needs.
5730
+ * When your component renders, `useCancelBroadcastMutation` returns a tuple that includes:
5553
5731
  * - A mutate function that you can call at any time to execute the mutation
5554
5732
  * - An object with fields that represent the current status of the mutation's execution
5555
5733
  *
5556
5734
  * @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;
5557
5735
  *
5558
5736
  * @example
5559
- * const [bulkImportContactsMutation, { data, loading, error }] = useBulkImportContactsMutation({
5737
+ * const [cancelBroadcastMutation, { data, loading, error }] = useCancelBroadcastMutation({
5560
5738
  * variables: {
5561
5739
  * input: // value for 'input'
5562
5740
  * },
5563
5741
  * });
5564
5742
  */
5565
- export declare function useBulkImportContactsMutation(baseOptions?: Apollo.MutationHookOptions<BulkImportContactsMutation, BulkImportContactsMutationVariables>): Apollo.MutationTuple<BulkImportContactsMutation, Exact<{
5566
- input: BulkImportContactsInput;
5743
+ export declare function useCancelBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<CancelBroadcastMutation, CancelBroadcastMutationVariables>): Apollo.MutationTuple<CancelBroadcastMutation, Exact<{
5744
+ input: BroadcastCancelInput;
5567
5745
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5568
- export type BulkImportContactsMutationHookResult = ReturnType<typeof useBulkImportContactsMutation>;
5569
- export type BulkImportContactsMutationResult = Apollo.MutationResult<BulkImportContactsMutation>;
5570
- export type BulkImportContactsMutationOptions = Apollo.BaseMutationOptions<BulkImportContactsMutation, BulkImportContactsMutationVariables>;
5571
- export declare const BulkImportContactsJobStatusDocument: Apollo.DocumentNode;
5746
+ export type CancelBroadcastMutationHookResult = ReturnType<typeof useCancelBroadcastMutation>;
5747
+ export type CancelBroadcastMutationResult = Apollo.MutationResult<CancelBroadcastMutation>;
5748
+ export type CancelBroadcastMutationOptions = Apollo.BaseMutationOptions<CancelBroadcastMutation, CancelBroadcastMutationVariables>;
5749
+ export declare const ConvsDocument: Apollo.DocumentNode;
5750
+ /**
5751
+ * __useConvsQuery__
5752
+ *
5753
+ * To run a query within a React component, call `useConvsQuery` and pass it any options that fit your needs.
5754
+ * When your component renders, `useConvsQuery` returns an object from Apollo Client that contains loading, error, and data properties
5755
+ * you can use to render your UI.
5756
+ *
5757
+ * @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;
5758
+ *
5759
+ * @example
5760
+ * const { data, loading, error } = useConvsQuery({
5761
+ * variables: {
5762
+ * input: // value for 'input'
5763
+ * pageInfo: // value for 'pageInfo'
5764
+ * },
5765
+ * });
5766
+ */
5767
+ export declare function useConvsQuery(baseOptions: Apollo.QueryHookOptions<ConvsQuery, ConvsQueryVariables> & ({
5768
+ variables: ConvsQueryVariables;
5769
+ skip?: boolean;
5770
+ } | {
5771
+ skip: boolean;
5772
+ })): Apollo.QueryResult<ConvsQuery, Exact<{
5773
+ input: ConvsInput;
5774
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5775
+ }>>;
5776
+ export declare function useConvsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ConvsQuery, ConvsQueryVariables>): Apollo.LazyQueryResultTuple<ConvsQuery, Exact<{
5777
+ input: ConvsInput;
5778
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5779
+ }>>;
5780
+ export declare function useConvsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ConvsQuery, ConvsQueryVariables>): Apollo.UseSuspenseQueryResult<ConvsQuery | undefined, Exact<{
5781
+ input: ConvsInput;
5782
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5783
+ }>>;
5784
+ export type ConvsQueryHookResult = ReturnType<typeof useConvsQuery>;
5785
+ export type ConvsLazyQueryHookResult = ReturnType<typeof useConvsLazyQuery>;
5786
+ export type ConvsSuspenseQueryHookResult = ReturnType<typeof useConvsSuspenseQuery>;
5787
+ export type ConvsQueryResult = Apollo.QueryResult<ConvsQuery, ConvsQueryVariables>;
5788
+ export declare function refetchConvsQuery(variables: ConvsQueryVariables): {
5789
+ query: Apollo.DocumentNode;
5790
+ variables: Exact<{
5791
+ input: ConvsInput;
5792
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5793
+ }>;
5794
+ };
5795
+ export declare const CreateAgentDocument: Apollo.DocumentNode;
5796
+ export type CreateAgentMutationFn = Apollo.MutationFunction<CreateAgentMutation, CreateAgentMutationVariables>;
5797
+ /**
5798
+ * __useCreateAgentMutation__
5799
+ *
5800
+ * To run a mutation, you first call `useCreateAgentMutation` within a React component and pass it any options that fit your needs.
5801
+ * When your component renders, `useCreateAgentMutation` returns a tuple that includes:
5802
+ * - A mutate function that you can call at any time to execute the mutation
5803
+ * - An object with fields that represent the current status of the mutation's execution
5804
+ *
5805
+ * @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;
5806
+ *
5807
+ * @example
5808
+ * const [createAgentMutation, { data, loading, error }] = useCreateAgentMutation({
5809
+ * variables: {
5810
+ * input: // value for 'input'
5811
+ * },
5812
+ * });
5813
+ */
5814
+ export declare function useCreateAgentMutation(baseOptions?: Apollo.MutationHookOptions<CreateAgentMutation, CreateAgentMutationVariables>): Apollo.MutationTuple<CreateAgentMutation, Exact<{
5815
+ input: AgentCreateInput;
5816
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5817
+ export type CreateAgentMutationHookResult = ReturnType<typeof useCreateAgentMutation>;
5818
+ export type CreateAgentMutationResult = Apollo.MutationResult<CreateAgentMutation>;
5819
+ export type CreateAgentMutationOptions = Apollo.BaseMutationOptions<CreateAgentMutation, CreateAgentMutationVariables>;
5820
+ export declare const CreateBroadcastDocument: Apollo.DocumentNode;
5821
+ export type CreateBroadcastMutationFn = Apollo.MutationFunction<CreateBroadcastMutation, CreateBroadcastMutationVariables>;
5822
+ /**
5823
+ * __useCreateBroadcastMutation__
5824
+ *
5825
+ * To run a mutation, you first call `useCreateBroadcastMutation` within a React component and pass it any options that fit your needs.
5826
+ * When your component renders, `useCreateBroadcastMutation` returns a tuple that includes:
5827
+ * - A mutate function that you can call at any time to execute the mutation
5828
+ * - An object with fields that represent the current status of the mutation's execution
5829
+ *
5830
+ * @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;
5831
+ *
5832
+ * @example
5833
+ * const [createBroadcastMutation, { data, loading, error }] = useCreateBroadcastMutation({
5834
+ * variables: {
5835
+ * input: // value for 'input'
5836
+ * },
5837
+ * });
5838
+ */
5839
+ export declare function useCreateBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<CreateBroadcastMutation, CreateBroadcastMutationVariables>): Apollo.MutationTuple<CreateBroadcastMutation, Exact<{
5840
+ input: BroadcastCreateInput;
5841
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5842
+ export type CreateBroadcastMutationHookResult = ReturnType<typeof useCreateBroadcastMutation>;
5843
+ export type CreateBroadcastMutationResult = Apollo.MutationResult<CreateBroadcastMutation>;
5844
+ export type CreateBroadcastMutationOptions = Apollo.BaseMutationOptions<CreateBroadcastMutation, CreateBroadcastMutationVariables>;
5845
+ export declare const DeleteAgentDocument: Apollo.DocumentNode;
5846
+ export type DeleteAgentMutationFn = Apollo.MutationFunction<DeleteAgentMutation, DeleteAgentMutationVariables>;
5847
+ /**
5848
+ * __useDeleteAgentMutation__
5849
+ *
5850
+ * To run a mutation, you first call `useDeleteAgentMutation` within a React component and pass it any options that fit your needs.
5851
+ * When your component renders, `useDeleteAgentMutation` returns a tuple that includes:
5852
+ * - A mutate function that you can call at any time to execute the mutation
5853
+ * - An object with fields that represent the current status of the mutation's execution
5854
+ *
5855
+ * @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;
5856
+ *
5857
+ * @example
5858
+ * const [deleteAgentMutation, { data, loading, error }] = useDeleteAgentMutation({
5859
+ * variables: {
5860
+ * input: // value for 'input'
5861
+ * },
5862
+ * });
5863
+ */
5864
+ export declare function useDeleteAgentMutation(baseOptions?: Apollo.MutationHookOptions<DeleteAgentMutation, DeleteAgentMutationVariables>): Apollo.MutationTuple<DeleteAgentMutation, Exact<{
5865
+ input: AgentInput;
5866
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5867
+ export type DeleteAgentMutationHookResult = ReturnType<typeof useDeleteAgentMutation>;
5868
+ export type DeleteAgentMutationResult = Apollo.MutationResult<DeleteAgentMutation>;
5869
+ export type DeleteAgentMutationOptions = Apollo.BaseMutationOptions<DeleteAgentMutation, DeleteAgentMutationVariables>;
5870
+ export declare const DeleteBroadcastDocument: Apollo.DocumentNode;
5871
+ export type DeleteBroadcastMutationFn = Apollo.MutationFunction<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>;
5872
+ /**
5873
+ * __useDeleteBroadcastMutation__
5874
+ *
5875
+ * To run a mutation, you first call `useDeleteBroadcastMutation` within a React component and pass it any options that fit your needs.
5876
+ * When your component renders, `useDeleteBroadcastMutation` returns a tuple that includes:
5877
+ * - A mutate function that you can call at any time to execute the mutation
5878
+ * - An object with fields that represent the current status of the mutation's execution
5879
+ *
5880
+ * @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;
5881
+ *
5882
+ * @example
5883
+ * const [deleteBroadcastMutation, { data, loading, error }] = useDeleteBroadcastMutation({
5884
+ * variables: {
5885
+ * input: // value for 'input'
5886
+ * },
5887
+ * });
5888
+ */
5889
+ export declare function useDeleteBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>): Apollo.MutationTuple<DeleteBroadcastMutation, Exact<{
5890
+ input: BroadcastDeleteInput;
5891
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5892
+ export type DeleteBroadcastMutationHookResult = ReturnType<typeof useDeleteBroadcastMutation>;
5893
+ export type DeleteBroadcastMutationResult = Apollo.MutationResult<DeleteBroadcastMutation>;
5894
+ export type DeleteBroadcastMutationOptions = Apollo.BaseMutationOptions<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>;
5895
+ export declare const EndConvDocument: Apollo.DocumentNode;
5896
+ export type EndConvMutationFn = Apollo.MutationFunction<EndConvMutation, EndConvMutationVariables>;
5897
+ /**
5898
+ * __useEndConvMutation__
5899
+ *
5900
+ * To run a mutation, you first call `useEndConvMutation` within a React component and pass it any options that fit your needs.
5901
+ * When your component renders, `useEndConvMutation` returns a tuple that includes:
5902
+ * - A mutate function that you can call at any time to execute the mutation
5903
+ * - An object with fields that represent the current status of the mutation's execution
5904
+ *
5905
+ * @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;
5906
+ *
5907
+ * @example
5908
+ * const [endConvMutation, { data, loading, error }] = useEndConvMutation({
5909
+ * variables: {
5910
+ * input: // value for 'input'
5911
+ * },
5912
+ * });
5913
+ */
5914
+ export declare function useEndConvMutation(baseOptions?: Apollo.MutationHookOptions<EndConvMutation, EndConvMutationVariables>): Apollo.MutationTuple<EndConvMutation, Exact<{
5915
+ input: ConvEndInput;
5916
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5917
+ export type EndConvMutationHookResult = ReturnType<typeof useEndConvMutation>;
5918
+ export type EndConvMutationResult = Apollo.MutationResult<EndConvMutation>;
5919
+ export type EndConvMutationOptions = Apollo.BaseMutationOptions<EndConvMutation, EndConvMutationVariables>;
5920
+ export declare const LaunchBroadcastDocument: Apollo.DocumentNode;
5921
+ export type LaunchBroadcastMutationFn = Apollo.MutationFunction<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>;
5922
+ /**
5923
+ * __useLaunchBroadcastMutation__
5924
+ *
5925
+ * To run a mutation, you first call `useLaunchBroadcastMutation` within a React component and pass it any options that fit your needs.
5926
+ * When your component renders, `useLaunchBroadcastMutation` returns a tuple that includes:
5927
+ * - A mutate function that you can call at any time to execute the mutation
5928
+ * - An object with fields that represent the current status of the mutation's execution
5929
+ *
5930
+ * @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;
5931
+ *
5932
+ * @example
5933
+ * const [launchBroadcastMutation, { data, loading, error }] = useLaunchBroadcastMutation({
5934
+ * variables: {
5935
+ * input: // value for 'input'
5936
+ * },
5937
+ * });
5938
+ */
5939
+ export declare function useLaunchBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>): Apollo.MutationTuple<LaunchBroadcastMutation, Exact<{
5940
+ input: BroadcastLaunchInput;
5941
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5942
+ export type LaunchBroadcastMutationHookResult = ReturnType<typeof useLaunchBroadcastMutation>;
5943
+ export type LaunchBroadcastMutationResult = Apollo.MutationResult<LaunchBroadcastMutation>;
5944
+ export type LaunchBroadcastMutationOptions = Apollo.BaseMutationOptions<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>;
5945
+ export declare const MessagesDocument: Apollo.DocumentNode;
5946
+ /**
5947
+ * __useMessagesQuery__
5948
+ *
5949
+ * To run a query within a React component, call `useMessagesQuery` and pass it any options that fit your needs.
5950
+ * When your component renders, `useMessagesQuery` returns an object from Apollo Client that contains loading, error, and data properties
5951
+ * you can use to render your UI.
5952
+ *
5953
+ * @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;
5954
+ *
5955
+ * @example
5956
+ * const { data, loading, error } = useMessagesQuery({
5957
+ * variables: {
5958
+ * input: // value for 'input'
5959
+ * pageInfo: // value for 'pageInfo'
5960
+ * },
5961
+ * });
5962
+ */
5963
+ export declare function useMessagesQuery(baseOptions: Apollo.QueryHookOptions<MessagesQuery, MessagesQueryVariables> & ({
5964
+ variables: MessagesQueryVariables;
5965
+ skip?: boolean;
5966
+ } | {
5967
+ skip: boolean;
5968
+ })): Apollo.QueryResult<MessagesQuery, Exact<{
5969
+ input: MessagesInput;
5970
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5971
+ }>>;
5972
+ export declare function useMessagesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MessagesQuery, MessagesQueryVariables>): Apollo.LazyQueryResultTuple<MessagesQuery, Exact<{
5973
+ input: MessagesInput;
5974
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5975
+ }>>;
5976
+ export declare function useMessagesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<MessagesQuery, MessagesQueryVariables>): Apollo.UseSuspenseQueryResult<MessagesQuery | undefined, Exact<{
5977
+ input: MessagesInput;
5978
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5979
+ }>>;
5980
+ export type MessagesQueryHookResult = ReturnType<typeof useMessagesQuery>;
5981
+ export type MessagesLazyQueryHookResult = ReturnType<typeof useMessagesLazyQuery>;
5982
+ export type MessagesSuspenseQueryHookResult = ReturnType<typeof useMessagesSuspenseQuery>;
5983
+ export type MessagesQueryResult = Apollo.QueryResult<MessagesQuery, MessagesQueryVariables>;
5984
+ export declare function refetchMessagesQuery(variables: MessagesQueryVariables): {
5985
+ query: Apollo.DocumentNode;
5986
+ variables: Exact<{
5987
+ input: MessagesInput;
5988
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
5989
+ }>;
5990
+ };
5991
+ export declare const OpenConversationsNeedResponseCountDocument: Apollo.DocumentNode;
5572
5992
  /**
5573
- * __useBulkImportContactsJobStatusQuery__
5993
+ * __useOpenConversationsNeedResponseCountQuery__
5574
5994
  *
5575
- * To run a query within a React component, call `useBulkImportContactsJobStatusQuery` and pass it any options that fit your needs.
5576
- * When your component renders, `useBulkImportContactsJobStatusQuery` returns an object from Apollo Client that contains loading, error, and data properties
5995
+ * To run a query within a React component, call `useOpenConversationsNeedResponseCountQuery` and pass it any options that fit your needs.
5996
+ * When your component renders, `useOpenConversationsNeedResponseCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
5577
5997
  * you can use to render your UI.
5578
5998
  *
5579
5999
  * @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;
5580
6000
  *
5581
6001
  * @example
5582
- * const { data, loading, error } = useBulkImportContactsJobStatusQuery({
6002
+ * const { data, loading, error } = useOpenConversationsNeedResponseCountQuery({
5583
6003
  * variables: {
5584
6004
  * input: // value for 'input'
5585
6005
  * },
5586
6006
  * });
5587
6007
  */
5588
- export declare function useBulkImportContactsJobStatusQuery(baseOptions: Apollo.QueryHookOptions<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables> & ({
5589
- variables: BulkImportContactsJobStatusQueryVariables;
6008
+ export declare function useOpenConversationsNeedResponseCountQuery(baseOptions: Apollo.QueryHookOptions<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables> & ({
6009
+ variables: OpenConversationsNeedResponseCountQueryVariables;
5590
6010
  skip?: boolean;
5591
6011
  } | {
5592
6012
  skip: boolean;
5593
- })): Apollo.QueryResult<BulkImportContactsJobStatusQuery, Exact<{
5594
- input: BulkImportContactsJobStatusInput;
6013
+ })): Apollo.QueryResult<OpenConversationsNeedResponseCountQuery, Exact<{
6014
+ input: OpenConversationsNeedResponseInput;
5595
6015
  }>>;
5596
- export declare function useBulkImportContactsJobStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables>): Apollo.LazyQueryResultTuple<BulkImportContactsJobStatusQuery, Exact<{
5597
- input: BulkImportContactsJobStatusInput;
6016
+ export declare function useOpenConversationsNeedResponseCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables>): Apollo.LazyQueryResultTuple<OpenConversationsNeedResponseCountQuery, Exact<{
6017
+ input: OpenConversationsNeedResponseInput;
5598
6018
  }>>;
5599
- export declare function useBulkImportContactsJobStatusSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables>): Apollo.UseSuspenseQueryResult<BulkImportContactsJobStatusQuery | undefined, Exact<{
5600
- input: BulkImportContactsJobStatusInput;
6019
+ export declare function useOpenConversationsNeedResponseCountSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables>): Apollo.UseSuspenseQueryResult<OpenConversationsNeedResponseCountQuery | undefined, Exact<{
6020
+ input: OpenConversationsNeedResponseInput;
5601
6021
  }>>;
5602
- export type BulkImportContactsJobStatusQueryHookResult = ReturnType<typeof useBulkImportContactsJobStatusQuery>;
5603
- export type BulkImportContactsJobStatusLazyQueryHookResult = ReturnType<typeof useBulkImportContactsJobStatusLazyQuery>;
5604
- export type BulkImportContactsJobStatusSuspenseQueryHookResult = ReturnType<typeof useBulkImportContactsJobStatusSuspenseQuery>;
5605
- export type BulkImportContactsJobStatusQueryResult = Apollo.QueryResult<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables>;
5606
- export declare function refetchBulkImportContactsJobStatusQuery(variables: BulkImportContactsJobStatusQueryVariables): {
6022
+ export type OpenConversationsNeedResponseCountQueryHookResult = ReturnType<typeof useOpenConversationsNeedResponseCountQuery>;
6023
+ export type OpenConversationsNeedResponseCountLazyQueryHookResult = ReturnType<typeof useOpenConversationsNeedResponseCountLazyQuery>;
6024
+ export type OpenConversationsNeedResponseCountSuspenseQueryHookResult = ReturnType<typeof useOpenConversationsNeedResponseCountSuspenseQuery>;
6025
+ export type OpenConversationsNeedResponseCountQueryResult = Apollo.QueryResult<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables>;
6026
+ export declare function refetchOpenConversationsNeedResponseCountQuery(variables: OpenConversationsNeedResponseCountQueryVariables): {
5607
6027
  query: Apollo.DocumentNode;
5608
6028
  variables: Exact<{
5609
- input: BulkImportContactsJobStatusInput;
6029
+ input: OpenConversationsNeedResponseInput;
5610
6030
  }>;
5611
6031
  };
5612
- export declare const BulkPermanentDeleteClientsDocument: Apollo.DocumentNode;
5613
- export type BulkPermanentDeleteClientsMutationFn = Apollo.MutationFunction<BulkPermanentDeleteClientsMutation, BulkPermanentDeleteClientsMutationVariables>;
6032
+ export declare const PatchAgentDocument: Apollo.DocumentNode;
6033
+ export type PatchAgentMutationFn = Apollo.MutationFunction<PatchAgentMutation, PatchAgentMutationVariables>;
5614
6034
  /**
5615
- * __useBulkPermanentDeleteClientsMutation__
6035
+ * __usePatchAgentMutation__
5616
6036
  *
5617
- * To run a mutation, you first call `useBulkPermanentDeleteClientsMutation` within a React component and pass it any options that fit your needs.
5618
- * When your component renders, `useBulkPermanentDeleteClientsMutation` returns a tuple that includes:
6037
+ * To run a mutation, you first call `usePatchAgentMutation` within a React component and pass it any options that fit your needs.
6038
+ * When your component renders, `usePatchAgentMutation` returns a tuple that includes:
5619
6039
  * - A mutate function that you can call at any time to execute the mutation
5620
6040
  * - An object with fields that represent the current status of the mutation's execution
5621
6041
  *
5622
6042
  * @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;
5623
6043
  *
5624
6044
  * @example
5625
- * const [bulkPermanentDeleteClientsMutation, { data, loading, error }] = useBulkPermanentDeleteClientsMutation({
6045
+ * const [patchAgentMutation, { data, loading, error }] = usePatchAgentMutation({
5626
6046
  * variables: {
5627
6047
  * input: // value for 'input'
5628
6048
  * },
5629
6049
  * });
5630
6050
  */
5631
- export declare function useBulkPermanentDeleteClientsMutation(baseOptions?: Apollo.MutationHookOptions<BulkPermanentDeleteClientsMutation, BulkPermanentDeleteClientsMutationVariables>): Apollo.MutationTuple<BulkPermanentDeleteClientsMutation, Exact<{
5632
- input: BulkPermanentDeleteClientsInput;
6051
+ export declare function usePatchAgentMutation(baseOptions?: Apollo.MutationHookOptions<PatchAgentMutation, PatchAgentMutationVariables>): Apollo.MutationTuple<PatchAgentMutation, Exact<{
6052
+ input: AgentPatchInput;
5633
6053
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5634
- export type BulkPermanentDeleteClientsMutationHookResult = ReturnType<typeof useBulkPermanentDeleteClientsMutation>;
5635
- export type BulkPermanentDeleteClientsMutationResult = Apollo.MutationResult<BulkPermanentDeleteClientsMutation>;
5636
- export type BulkPermanentDeleteClientsMutationOptions = Apollo.BaseMutationOptions<BulkPermanentDeleteClientsMutation, BulkPermanentDeleteClientsMutationVariables>;
5637
- export declare const BulkPermanentDeleteClientsByFilterDocument: Apollo.DocumentNode;
5638
- export type BulkPermanentDeleteClientsByFilterMutationFn = Apollo.MutationFunction<BulkPermanentDeleteClientsByFilterMutation, BulkPermanentDeleteClientsByFilterMutationVariables>;
6054
+ export type PatchAgentMutationHookResult = ReturnType<typeof usePatchAgentMutation>;
6055
+ export type PatchAgentMutationResult = Apollo.MutationResult<PatchAgentMutation>;
6056
+ export type PatchAgentMutationOptions = Apollo.BaseMutationOptions<PatchAgentMutation, PatchAgentMutationVariables>;
6057
+ export declare const PatchBroadcastDocument: Apollo.DocumentNode;
6058
+ export type PatchBroadcastMutationFn = Apollo.MutationFunction<PatchBroadcastMutation, PatchBroadcastMutationVariables>;
5639
6059
  /**
5640
- * __useBulkPermanentDeleteClientsByFilterMutation__
6060
+ * __usePatchBroadcastMutation__
5641
6061
  *
5642
- * To run a mutation, you first call `useBulkPermanentDeleteClientsByFilterMutation` within a React component and pass it any options that fit your needs.
5643
- * When your component renders, `useBulkPermanentDeleteClientsByFilterMutation` returns a tuple that includes:
6062
+ * To run a mutation, you first call `usePatchBroadcastMutation` within a React component and pass it any options that fit your needs.
6063
+ * When your component renders, `usePatchBroadcastMutation` returns a tuple that includes:
5644
6064
  * - A mutate function that you can call at any time to execute the mutation
5645
6065
  * - An object with fields that represent the current status of the mutation's execution
5646
6066
  *
5647
6067
  * @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;
5648
6068
  *
5649
6069
  * @example
5650
- * const [bulkPermanentDeleteClientsByFilterMutation, { data, loading, error }] = useBulkPermanentDeleteClientsByFilterMutation({
6070
+ * const [patchBroadcastMutation, { data, loading, error }] = usePatchBroadcastMutation({
5651
6071
  * variables: {
5652
6072
  * input: // value for 'input'
5653
6073
  * },
5654
6074
  * });
5655
6075
  */
5656
- export declare function useBulkPermanentDeleteClientsByFilterMutation(baseOptions?: Apollo.MutationHookOptions<BulkPermanentDeleteClientsByFilterMutation, BulkPermanentDeleteClientsByFilterMutationVariables>): Apollo.MutationTuple<BulkPermanentDeleteClientsByFilterMutation, Exact<{
5657
- input: BulkPermanentDeleteClientsByFilterInput;
6076
+ export declare function usePatchBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<PatchBroadcastMutation, PatchBroadcastMutationVariables>): Apollo.MutationTuple<PatchBroadcastMutation, Exact<{
6077
+ input: BroadcastPatchInput;
5658
6078
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5659
- export type BulkPermanentDeleteClientsByFilterMutationHookResult = ReturnType<typeof useBulkPermanentDeleteClientsByFilterMutation>;
5660
- export type BulkPermanentDeleteClientsByFilterMutationResult = Apollo.MutationResult<BulkPermanentDeleteClientsByFilterMutation>;
5661
- export type BulkPermanentDeleteClientsByFilterMutationOptions = Apollo.BaseMutationOptions<BulkPermanentDeleteClientsByFilterMutation, BulkPermanentDeleteClientsByFilterMutationVariables>;
5662
- export declare const CancelBroadcastDocument: Apollo.DocumentNode;
5663
- export type CancelBroadcastMutationFn = Apollo.MutationFunction<CancelBroadcastMutation, CancelBroadcastMutationVariables>;
6079
+ export type PatchBroadcastMutationHookResult = ReturnType<typeof usePatchBroadcastMutation>;
6080
+ export type PatchBroadcastMutationResult = Apollo.MutationResult<PatchBroadcastMutation>;
6081
+ export type PatchBroadcastMutationOptions = Apollo.BaseMutationOptions<PatchBroadcastMutation, PatchBroadcastMutationVariables>;
6082
+ export declare const PatchConvDocument: Apollo.DocumentNode;
6083
+ export type PatchConvMutationFn = Apollo.MutationFunction<PatchConvMutation, PatchConvMutationVariables>;
5664
6084
  /**
5665
- * __useCancelBroadcastMutation__
6085
+ * __usePatchConvMutation__
5666
6086
  *
5667
- * To run a mutation, you first call `useCancelBroadcastMutation` within a React component and pass it any options that fit your needs.
5668
- * When your component renders, `useCancelBroadcastMutation` returns a tuple that includes:
6087
+ * To run a mutation, you first call `usePatchConvMutation` within a React component and pass it any options that fit your needs.
6088
+ * When your component renders, `usePatchConvMutation` returns a tuple that includes:
5669
6089
  * - A mutate function that you can call at any time to execute the mutation
5670
6090
  * - An object with fields that represent the current status of the mutation's execution
5671
6091
  *
5672
6092
  * @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;
5673
6093
  *
5674
6094
  * @example
5675
- * const [cancelBroadcastMutation, { data, loading, error }] = useCancelBroadcastMutation({
6095
+ * const [patchConvMutation, { data, loading, error }] = usePatchConvMutation({
5676
6096
  * variables: {
5677
6097
  * input: // value for 'input'
5678
6098
  * },
5679
6099
  * });
5680
6100
  */
5681
- export declare function useCancelBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<CancelBroadcastMutation, CancelBroadcastMutationVariables>): Apollo.MutationTuple<CancelBroadcastMutation, Exact<{
5682
- input: BroadcastCancelInput;
6101
+ export declare function usePatchConvMutation(baseOptions?: Apollo.MutationHookOptions<PatchConvMutation, PatchConvMutationVariables>): Apollo.MutationTuple<PatchConvMutation, Exact<{
6102
+ input: ConvPatchInput;
5683
6103
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5684
- export type CancelBroadcastMutationHookResult = ReturnType<typeof useCancelBroadcastMutation>;
5685
- export type CancelBroadcastMutationResult = Apollo.MutationResult<CancelBroadcastMutation>;
5686
- export type CancelBroadcastMutationOptions = Apollo.BaseMutationOptions<CancelBroadcastMutation, CancelBroadcastMutationVariables>;
5687
- export declare const ClientDocument: Apollo.DocumentNode;
6104
+ export type PatchConvMutationHookResult = ReturnType<typeof usePatchConvMutation>;
6105
+ export type PatchConvMutationResult = Apollo.MutationResult<PatchConvMutation>;
6106
+ export type PatchConvMutationOptions = Apollo.BaseMutationOptions<PatchConvMutation, PatchConvMutationVariables>;
6107
+ export declare const StartConvDocument: Apollo.DocumentNode;
6108
+ export type StartConvMutationFn = Apollo.MutationFunction<StartConvMutation, StartConvMutationVariables>;
5688
6109
  /**
5689
- * __useClientQuery__
6110
+ * __useStartConvMutation__
5690
6111
  *
5691
- * To run a query within a React component, call `useClientQuery` and pass it any options that fit your needs.
5692
- * When your component renders, `useClientQuery` returns an object from Apollo Client that contains loading, error, and data properties
5693
- * you can use to render your UI.
6112
+ * To run a mutation, you first call `useStartConvMutation` within a React component and pass it any options that fit your needs.
6113
+ * When your component renders, `useStartConvMutation` returns a tuple that includes:
6114
+ * - A mutate function that you can call at any time to execute the mutation
6115
+ * - An object with fields that represent the current status of the mutation's execution
5694
6116
  *
5695
- * @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;
6117
+ * @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;
5696
6118
  *
5697
6119
  * @example
5698
- * const { data, loading, error } = useClientQuery({
6120
+ * const [startConvMutation, { data, loading, error }] = useStartConvMutation({
5699
6121
  * variables: {
5700
6122
  * input: // value for 'input'
5701
6123
  * },
5702
6124
  * });
5703
6125
  */
5704
- export declare function useClientQuery(baseOptions: Apollo.QueryHookOptions<ClientQuery, ClientQueryVariables> & ({
5705
- variables: ClientQueryVariables;
5706
- skip?: boolean;
5707
- } | {
5708
- skip: boolean;
5709
- })): Apollo.QueryResult<ClientQuery, Exact<{
5710
- input: ClientInput;
5711
- }>>;
5712
- export declare function useClientLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientQuery, ClientQueryVariables>): Apollo.LazyQueryResultTuple<ClientQuery, Exact<{
5713
- input: ClientInput;
5714
- }>>;
5715
- export declare function useClientSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientQuery, ClientQueryVariables>): Apollo.UseSuspenseQueryResult<ClientQuery | undefined, Exact<{
5716
- input: ClientInput;
5717
- }>>;
5718
- export type ClientQueryHookResult = ReturnType<typeof useClientQuery>;
5719
- export type ClientLazyQueryHookResult = ReturnType<typeof useClientLazyQuery>;
5720
- export type ClientSuspenseQueryHookResult = ReturnType<typeof useClientSuspenseQuery>;
5721
- export type ClientQueryResult = Apollo.QueryResult<ClientQuery, ClientQueryVariables>;
5722
- export declare function refetchClientQuery(variables: ClientQueryVariables): {
5723
- query: Apollo.DocumentNode;
5724
- variables: Exact<{
5725
- input: ClientInput;
5726
- }>;
5727
- };
5728
- export declare const ClientByPhoneDocument: Apollo.DocumentNode;
6126
+ export declare function useStartConvMutation(baseOptions?: Apollo.MutationHookOptions<StartConvMutation, StartConvMutationVariables>): Apollo.MutationTuple<StartConvMutation, Exact<{
6127
+ input: ConvStartInput;
6128
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6129
+ export type StartConvMutationHookResult = ReturnType<typeof useStartConvMutation>;
6130
+ export type StartConvMutationResult = Apollo.MutationResult<StartConvMutation>;
6131
+ export type StartConvMutationOptions = Apollo.BaseMutationOptions<StartConvMutation, StartConvMutationVariables>;
6132
+ export declare const TagClientDocument: Apollo.DocumentNode;
6133
+ export type TagClientMutationFn = Apollo.MutationFunction<TagClientMutation, TagClientMutationVariables>;
5729
6134
  /**
5730
- * __useClientByPhoneQuery__
6135
+ * __useTagClientMutation__
5731
6136
  *
5732
- * To run a query within a React component, call `useClientByPhoneQuery` and pass it any options that fit your needs.
5733
- * When your component renders, `useClientByPhoneQuery` returns an object from Apollo Client that contains loading, error, and data properties
5734
- * you can use to render your UI.
6137
+ * To run a mutation, you first call `useTagClientMutation` within a React component and pass it any options that fit your needs.
6138
+ * When your component renders, `useTagClientMutation` returns a tuple that includes:
6139
+ * - A mutate function that you can call at any time to execute the mutation
6140
+ * - An object with fields that represent the current status of the mutation's execution
5735
6141
  *
5736
- * @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;
6142
+ * @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;
5737
6143
  *
5738
6144
  * @example
5739
- * const { data, loading, error } = useClientByPhoneQuery({
6145
+ * const [tagClientMutation, { data, loading, error }] = useTagClientMutation({
5740
6146
  * variables: {
5741
6147
  * input: // value for 'input'
5742
6148
  * },
5743
6149
  * });
5744
6150
  */
5745
- export declare function useClientByPhoneQuery(baseOptions: Apollo.QueryHookOptions<ClientByPhoneQuery, ClientByPhoneQueryVariables> & ({
5746
- variables: ClientByPhoneQueryVariables;
5747
- skip?: boolean;
5748
- } | {
5749
- skip: boolean;
5750
- })): Apollo.QueryResult<ClientByPhoneQuery, Exact<{
5751
- input: ClientByPhoneInput;
5752
- }>>;
5753
- export declare function useClientByPhoneLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientByPhoneQuery, ClientByPhoneQueryVariables>): Apollo.LazyQueryResultTuple<ClientByPhoneQuery, Exact<{
5754
- input: ClientByPhoneInput;
5755
- }>>;
5756
- export declare function useClientByPhoneSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientByPhoneQuery, ClientByPhoneQueryVariables>): Apollo.UseSuspenseQueryResult<ClientByPhoneQuery | undefined, Exact<{
5757
- input: ClientByPhoneInput;
5758
- }>>;
5759
- export type ClientByPhoneQueryHookResult = ReturnType<typeof useClientByPhoneQuery>;
5760
- export type ClientByPhoneLazyQueryHookResult = ReturnType<typeof useClientByPhoneLazyQuery>;
5761
- export type ClientByPhoneSuspenseQueryHookResult = ReturnType<typeof useClientByPhoneSuspenseQuery>;
5762
- export type ClientByPhoneQueryResult = Apollo.QueryResult<ClientByPhoneQuery, ClientByPhoneQueryVariables>;
5763
- export declare function refetchClientByPhoneQuery(variables: ClientByPhoneQueryVariables): {
5764
- query: Apollo.DocumentNode;
5765
- variables: Exact<{
5766
- input: ClientByPhoneInput;
5767
- }>;
5768
- };
5769
- export declare const ClientsDocument: Apollo.DocumentNode;
6151
+ export declare function useTagClientMutation(baseOptions?: Apollo.MutationHookOptions<TagClientMutation, TagClientMutationVariables>): Apollo.MutationTuple<TagClientMutation, Exact<{
6152
+ input: ClientTagInput;
6153
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6154
+ export type TagClientMutationHookResult = ReturnType<typeof useTagClientMutation>;
6155
+ export type TagClientMutationResult = Apollo.MutationResult<TagClientMutation>;
6156
+ export type TagClientMutationOptions = Apollo.BaseMutationOptions<TagClientMutation, TagClientMutationVariables>;
6157
+ export declare const TagConvDocument: Apollo.DocumentNode;
6158
+ export type TagConvMutationFn = Apollo.MutationFunction<TagConvMutation, TagConvMutationVariables>;
5770
6159
  /**
5771
- * __useClientsQuery__
5772
- *
5773
- * To run a query within a React component, call `useClientsQuery` and pass it any options that fit your needs.
5774
- * When your component renders, `useClientsQuery` returns an object from Apollo Client that contains loading, error, and data properties
5775
- * you can use to render your UI.
5776
- *
5777
- * @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;
6160
+ * __useTagConvMutation__
5778
6161
  *
5779
- * @example
5780
- * const { data, loading, error } = useClientsQuery({
5781
- * variables: {
5782
- * input: // value for 'input'
5783
- * pageInfo: // value for 'pageInfo'
5784
- * },
5785
- * });
5786
- */
5787
- export declare function useClientsQuery(baseOptions: Apollo.QueryHookOptions<ClientsQuery, ClientsQueryVariables> & ({
5788
- variables: ClientsQueryVariables;
5789
- skip?: boolean;
5790
- } | {
5791
- skip: boolean;
5792
- })): Apollo.QueryResult<ClientsQuery, Exact<{
5793
- input: ClientsInput;
5794
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
5795
- }>>;
5796
- export declare function useClientsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientsQuery, ClientsQueryVariables>): Apollo.LazyQueryResultTuple<ClientsQuery, Exact<{
5797
- input: ClientsInput;
5798
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
5799
- }>>;
5800
- export declare function useClientsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientsQuery, ClientsQueryVariables>): Apollo.UseSuspenseQueryResult<ClientsQuery | undefined, Exact<{
5801
- input: ClientsInput;
5802
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
5803
- }>>;
5804
- export type ClientsQueryHookResult = ReturnType<typeof useClientsQuery>;
5805
- export type ClientsLazyQueryHookResult = ReturnType<typeof useClientsLazyQuery>;
5806
- export type ClientsSuspenseQueryHookResult = ReturnType<typeof useClientsSuspenseQuery>;
5807
- export type ClientsQueryResult = Apollo.QueryResult<ClientsQuery, ClientsQueryVariables>;
5808
- export declare function refetchClientsQuery(variables: ClientsQueryVariables): {
5809
- query: Apollo.DocumentNode;
5810
- variables: Exact<{
5811
- input: ClientsInput;
5812
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
5813
- }>;
5814
- };
5815
- export declare const ConvsDocument: Apollo.DocumentNode;
6162
+ * To run a mutation, you first call `useTagConvMutation` within a React component and pass it any options that fit your needs.
6163
+ * When your component renders, `useTagConvMutation` returns a tuple that includes:
6164
+ * - A mutate function that you can call at any time to execute the mutation
6165
+ * - An object with fields that represent the current status of the mutation's execution
6166
+ *
6167
+ * @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;
6168
+ *
6169
+ * @example
6170
+ * const [tagConvMutation, { data, loading, error }] = useTagConvMutation({
6171
+ * variables: {
6172
+ * input: // value for 'input'
6173
+ * },
6174
+ * });
6175
+ */
6176
+ export declare function useTagConvMutation(baseOptions?: Apollo.MutationHookOptions<TagConvMutation, TagConvMutationVariables>): Apollo.MutationTuple<TagConvMutation, Exact<{
6177
+ input: ConvTagInput;
6178
+ }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6179
+ export type TagConvMutationHookResult = ReturnType<typeof useTagConvMutation>;
6180
+ export type TagConvMutationResult = Apollo.MutationResult<TagConvMutation>;
6181
+ export type TagConvMutationOptions = Apollo.BaseMutationOptions<TagConvMutation, TagConvMutationVariables>;
6182
+ export declare const TagsDocument: Apollo.DocumentNode;
5816
6183
  /**
5817
- * __useConvsQuery__
6184
+ * __useTagsQuery__
5818
6185
  *
5819
- * To run a query within a React component, call `useConvsQuery` and pass it any options that fit your needs.
5820
- * When your component renders, `useConvsQuery` returns an object from Apollo Client that contains loading, error, and data properties
6186
+ * To run a query within a React component, call `useTagsQuery` and pass it any options that fit your needs.
6187
+ * When your component renders, `useTagsQuery` returns an object from Apollo Client that contains loading, error, and data properties
5821
6188
  * you can use to render your UI.
5822
6189
  *
5823
6190
  * @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;
5824
6191
  *
5825
6192
  * @example
5826
- * const { data, loading, error } = useConvsQuery({
6193
+ * const { data, loading, error } = useTagsQuery({
5827
6194
  * variables: {
5828
6195
  * input: // value for 'input'
5829
- * pageInfo: // value for 'pageInfo'
5830
6196
  * },
5831
6197
  * });
5832
6198
  */
5833
- export declare function useConvsQuery(baseOptions: Apollo.QueryHookOptions<ConvsQuery, ConvsQueryVariables> & ({
5834
- variables: ConvsQueryVariables;
6199
+ export declare function useTagsQuery(baseOptions: Apollo.QueryHookOptions<TagsQuery, TagsQueryVariables> & ({
6200
+ variables: TagsQueryVariables;
5835
6201
  skip?: boolean;
5836
6202
  } | {
5837
6203
  skip: boolean;
5838
- })): Apollo.QueryResult<ConvsQuery, Exact<{
5839
- input: ConvsInput;
5840
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6204
+ })): Apollo.QueryResult<TagsQuery, Exact<{
6205
+ input: TagsInput;
5841
6206
  }>>;
5842
- export declare function useConvsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ConvsQuery, ConvsQueryVariables>): Apollo.LazyQueryResultTuple<ConvsQuery, Exact<{
5843
- input: ConvsInput;
5844
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6207
+ export declare function useTagsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TagsQuery, TagsQueryVariables>): Apollo.LazyQueryResultTuple<TagsQuery, Exact<{
6208
+ input: TagsInput;
5845
6209
  }>>;
5846
- export declare function useConvsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ConvsQuery, ConvsQueryVariables>): Apollo.UseSuspenseQueryResult<ConvsQuery | undefined, Exact<{
5847
- input: ConvsInput;
5848
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6210
+ export declare function useTagsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<TagsQuery, TagsQueryVariables>): Apollo.UseSuspenseQueryResult<TagsQuery | undefined, Exact<{
6211
+ input: TagsInput;
5849
6212
  }>>;
5850
- export type ConvsQueryHookResult = ReturnType<typeof useConvsQuery>;
5851
- export type ConvsLazyQueryHookResult = ReturnType<typeof useConvsLazyQuery>;
5852
- export type ConvsSuspenseQueryHookResult = ReturnType<typeof useConvsSuspenseQuery>;
5853
- export type ConvsQueryResult = Apollo.QueryResult<ConvsQuery, ConvsQueryVariables>;
5854
- export declare function refetchConvsQuery(variables: ConvsQueryVariables): {
6213
+ export type TagsQueryHookResult = ReturnType<typeof useTagsQuery>;
6214
+ export type TagsLazyQueryHookResult = ReturnType<typeof useTagsLazyQuery>;
6215
+ export type TagsSuspenseQueryHookResult = ReturnType<typeof useTagsSuspenseQuery>;
6216
+ export type TagsQueryResult = Apollo.QueryResult<TagsQuery, TagsQueryVariables>;
6217
+ export declare function refetchTagsQuery(variables: TagsQueryVariables): {
5855
6218
  query: Apollo.DocumentNode;
5856
6219
  variables: Exact<{
5857
- input: ConvsInput;
5858
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6220
+ input: TagsInput;
5859
6221
  }>;
5860
6222
  };
5861
- export declare const CreateAgentDocument: Apollo.DocumentNode;
5862
- export type CreateAgentMutationFn = Apollo.MutationFunction<CreateAgentMutation, CreateAgentMutationVariables>;
6223
+ export declare const UntagClientDocument: Apollo.DocumentNode;
6224
+ export type UntagClientMutationFn = Apollo.MutationFunction<UntagClientMutation, UntagClientMutationVariables>;
5863
6225
  /**
5864
- * __useCreateAgentMutation__
6226
+ * __useUntagClientMutation__
5865
6227
  *
5866
- * To run a mutation, you first call `useCreateAgentMutation` within a React component and pass it any options that fit your needs.
5867
- * When your component renders, `useCreateAgentMutation` returns a tuple that includes:
6228
+ * To run a mutation, you first call `useUntagClientMutation` within a React component and pass it any options that fit your needs.
6229
+ * When your component renders, `useUntagClientMutation` returns a tuple that includes:
5868
6230
  * - A mutate function that you can call at any time to execute the mutation
5869
6231
  * - An object with fields that represent the current status of the mutation's execution
5870
6232
  *
5871
6233
  * @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;
5872
6234
  *
5873
6235
  * @example
5874
- * const [createAgentMutation, { data, loading, error }] = useCreateAgentMutation({
6236
+ * const [untagClientMutation, { data, loading, error }] = useUntagClientMutation({
5875
6237
  * variables: {
5876
6238
  * input: // value for 'input'
5877
6239
  * },
5878
6240
  * });
5879
6241
  */
5880
- export declare function useCreateAgentMutation(baseOptions?: Apollo.MutationHookOptions<CreateAgentMutation, CreateAgentMutationVariables>): Apollo.MutationTuple<CreateAgentMutation, Exact<{
5881
- input: AgentCreateInput;
6242
+ export declare function useUntagClientMutation(baseOptions?: Apollo.MutationHookOptions<UntagClientMutation, UntagClientMutationVariables>): Apollo.MutationTuple<UntagClientMutation, Exact<{
6243
+ input: ClientTagInput;
5882
6244
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5883
- export type CreateAgentMutationHookResult = ReturnType<typeof useCreateAgentMutation>;
5884
- export type CreateAgentMutationResult = Apollo.MutationResult<CreateAgentMutation>;
5885
- export type CreateAgentMutationOptions = Apollo.BaseMutationOptions<CreateAgentMutation, CreateAgentMutationVariables>;
5886
- export declare const CreateBroadcastDocument: Apollo.DocumentNode;
5887
- export type CreateBroadcastMutationFn = Apollo.MutationFunction<CreateBroadcastMutation, CreateBroadcastMutationVariables>;
6245
+ export type UntagClientMutationHookResult = ReturnType<typeof useUntagClientMutation>;
6246
+ export type UntagClientMutationResult = Apollo.MutationResult<UntagClientMutation>;
6247
+ export type UntagClientMutationOptions = Apollo.BaseMutationOptions<UntagClientMutation, UntagClientMutationVariables>;
6248
+ export declare const UntagConvDocument: Apollo.DocumentNode;
6249
+ export type UntagConvMutationFn = Apollo.MutationFunction<UntagConvMutation, UntagConvMutationVariables>;
5888
6250
  /**
5889
- * __useCreateBroadcastMutation__
6251
+ * __useUntagConvMutation__
5890
6252
  *
5891
- * To run a mutation, you first call `useCreateBroadcastMutation` within a React component and pass it any options that fit your needs.
5892
- * When your component renders, `useCreateBroadcastMutation` returns a tuple that includes:
6253
+ * To run a mutation, you first call `useUntagConvMutation` within a React component and pass it any options that fit your needs.
6254
+ * When your component renders, `useUntagConvMutation` returns a tuple that includes:
5893
6255
  * - A mutate function that you can call at any time to execute the mutation
5894
6256
  * - An object with fields that represent the current status of the mutation's execution
5895
6257
  *
5896
6258
  * @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;
5897
6259
  *
5898
6260
  * @example
5899
- * const [createBroadcastMutation, { data, loading, error }] = useCreateBroadcastMutation({
6261
+ * const [untagConvMutation, { data, loading, error }] = useUntagConvMutation({
5900
6262
  * variables: {
5901
6263
  * input: // value for 'input'
5902
6264
  * },
5903
6265
  * });
5904
6266
  */
5905
- export declare function useCreateBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<CreateBroadcastMutation, CreateBroadcastMutationVariables>): Apollo.MutationTuple<CreateBroadcastMutation, Exact<{
5906
- input: BroadcastCreateInput;
6267
+ export declare function useUntagConvMutation(baseOptions?: Apollo.MutationHookOptions<UntagConvMutation, UntagConvMutationVariables>): Apollo.MutationTuple<UntagConvMutation, Exact<{
6268
+ input: ConvTagInput;
5907
6269
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5908
- export type CreateBroadcastMutationHookResult = ReturnType<typeof useCreateBroadcastMutation>;
5909
- export type CreateBroadcastMutationResult = Apollo.MutationResult<CreateBroadcastMutation>;
5910
- export type CreateBroadcastMutationOptions = Apollo.BaseMutationOptions<CreateBroadcastMutation, CreateBroadcastMutationVariables>;
5911
- export declare const CreateClientDocument: Apollo.DocumentNode;
5912
- export type CreateClientMutationFn = Apollo.MutationFunction<CreateClientMutation, CreateClientMutationVariables>;
6270
+ export type UntagConvMutationHookResult = ReturnType<typeof useUntagConvMutation>;
6271
+ export type UntagConvMutationResult = Apollo.MutationResult<UntagConvMutation>;
6272
+ export type UntagConvMutationOptions = Apollo.BaseMutationOptions<UntagConvMutation, UntagConvMutationVariables>;
6273
+ export declare const WabaMessageTemplateDetailsDocument: Apollo.DocumentNode;
5913
6274
  /**
5914
- * __useCreateClientMutation__
6275
+ * __useWabaMessageTemplateDetailsQuery__
5915
6276
  *
5916
- * To run a mutation, you first call `useCreateClientMutation` within a React component and pass it any options that fit your needs.
5917
- * When your component renders, `useCreateClientMutation` returns a tuple that includes:
5918
- * - A mutate function that you can call at any time to execute the mutation
5919
- * - An object with fields that represent the current status of the mutation's execution
6277
+ * To run a query within a React component, call `useWabaMessageTemplateDetailsQuery` and pass it any options that fit your needs.
6278
+ * When your component renders, `useWabaMessageTemplateDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
6279
+ * you can use to render your UI.
5920
6280
  *
5921
- * @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;
6281
+ * @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;
5922
6282
  *
5923
6283
  * @example
5924
- * const [createClientMutation, { data, loading, error }] = useCreateClientMutation({
6284
+ * const { data, loading, error } = useWabaMessageTemplateDetailsQuery({
5925
6285
  * variables: {
5926
6286
  * input: // value for 'input'
5927
6287
  * },
5928
6288
  * });
5929
6289
  */
5930
- export declare function useCreateClientMutation(baseOptions?: Apollo.MutationHookOptions<CreateClientMutation, CreateClientMutationVariables>): Apollo.MutationTuple<CreateClientMutation, Exact<{
5931
- input: ClientCreateInput;
5932
- }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5933
- export type CreateClientMutationHookResult = ReturnType<typeof useCreateClientMutation>;
5934
- export type CreateClientMutationResult = Apollo.MutationResult<CreateClientMutation>;
5935
- export type CreateClientMutationOptions = Apollo.BaseMutationOptions<CreateClientMutation, CreateClientMutationVariables>;
5936
- export declare const DeleteAgentDocument: Apollo.DocumentNode;
5937
- export type DeleteAgentMutationFn = Apollo.MutationFunction<DeleteAgentMutation, DeleteAgentMutationVariables>;
6290
+ export declare function useWabaMessageTemplateDetailsQuery(baseOptions: Apollo.QueryHookOptions<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables> & ({
6291
+ variables: WabaMessageTemplateDetailsQueryVariables;
6292
+ skip?: boolean;
6293
+ } | {
6294
+ skip: boolean;
6295
+ })): Apollo.QueryResult<WabaMessageTemplateDetailsQuery, Exact<{
6296
+ input: WabaMessageTemplateDetailsInput;
6297
+ }>>;
6298
+ export declare function useWabaMessageTemplateDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables>): Apollo.LazyQueryResultTuple<WabaMessageTemplateDetailsQuery, Exact<{
6299
+ input: WabaMessageTemplateDetailsInput;
6300
+ }>>;
6301
+ export declare function useWabaMessageTemplateDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables>): Apollo.UseSuspenseQueryResult<WabaMessageTemplateDetailsQuery | undefined, Exact<{
6302
+ input: WabaMessageTemplateDetailsInput;
6303
+ }>>;
6304
+ export type WabaMessageTemplateDetailsQueryHookResult = ReturnType<typeof useWabaMessageTemplateDetailsQuery>;
6305
+ export type WabaMessageTemplateDetailsLazyQueryHookResult = ReturnType<typeof useWabaMessageTemplateDetailsLazyQuery>;
6306
+ export type WabaMessageTemplateDetailsSuspenseQueryHookResult = ReturnType<typeof useWabaMessageTemplateDetailsSuspenseQuery>;
6307
+ export type WabaMessageTemplateDetailsQueryResult = Apollo.QueryResult<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables>;
6308
+ export declare function refetchWabaMessageTemplateDetailsQuery(variables: WabaMessageTemplateDetailsQueryVariables): {
6309
+ query: Apollo.DocumentNode;
6310
+ variables: Exact<{
6311
+ input: WabaMessageTemplateDetailsInput;
6312
+ }>;
6313
+ };
6314
+ export declare const WabaMessageTemplatesDocument: Apollo.DocumentNode;
5938
6315
  /**
5939
- * __useDeleteAgentMutation__
6316
+ * __useWabaMessageTemplatesQuery__
5940
6317
  *
5941
- * To run a mutation, you first call `useDeleteAgentMutation` within a React component and pass it any options that fit your needs.
5942
- * When your component renders, `useDeleteAgentMutation` returns a tuple that includes:
5943
- * - A mutate function that you can call at any time to execute the mutation
5944
- * - An object with fields that represent the current status of the mutation's execution
6318
+ * To run a query within a React component, call `useWabaMessageTemplatesQuery` and pass it any options that fit your needs.
6319
+ * When your component renders, `useWabaMessageTemplatesQuery` returns an object from Apollo Client that contains loading, error, and data properties
6320
+ * you can use to render your UI.
5945
6321
  *
5946
- * @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;
6322
+ * @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;
5947
6323
  *
5948
6324
  * @example
5949
- * const [deleteAgentMutation, { data, loading, error }] = useDeleteAgentMutation({
6325
+ * const { data, loading, error } = useWabaMessageTemplatesQuery({
5950
6326
  * variables: {
5951
6327
  * input: // value for 'input'
5952
6328
  * },
5953
6329
  * });
5954
6330
  */
5955
- export declare function useDeleteAgentMutation(baseOptions?: Apollo.MutationHookOptions<DeleteAgentMutation, DeleteAgentMutationVariables>): Apollo.MutationTuple<DeleteAgentMutation, Exact<{
5956
- input: AgentInput;
5957
- }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5958
- export type DeleteAgentMutationHookResult = ReturnType<typeof useDeleteAgentMutation>;
5959
- export type DeleteAgentMutationResult = Apollo.MutationResult<DeleteAgentMutation>;
5960
- export type DeleteAgentMutationOptions = Apollo.BaseMutationOptions<DeleteAgentMutation, DeleteAgentMutationVariables>;
5961
- export declare const DeleteBroadcastDocument: Apollo.DocumentNode;
5962
- export type DeleteBroadcastMutationFn = Apollo.MutationFunction<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>;
6331
+ export declare function useWabaMessageTemplatesQuery(baseOptions: Apollo.QueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables> & ({
6332
+ variables: WabaMessageTemplatesQueryVariables;
6333
+ skip?: boolean;
6334
+ } | {
6335
+ skip: boolean;
6336
+ })): Apollo.QueryResult<WabaMessageTemplatesQuery, Exact<{
6337
+ input: WabaMessageTemplatesInput;
6338
+ }>>;
6339
+ export declare function useWabaMessageTemplatesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>): Apollo.LazyQueryResultTuple<WabaMessageTemplatesQuery, Exact<{
6340
+ input: WabaMessageTemplatesInput;
6341
+ }>>;
6342
+ export declare function useWabaMessageTemplatesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>): Apollo.UseSuspenseQueryResult<WabaMessageTemplatesQuery | undefined, Exact<{
6343
+ input: WabaMessageTemplatesInput;
6344
+ }>>;
6345
+ export type WabaMessageTemplatesQueryHookResult = ReturnType<typeof useWabaMessageTemplatesQuery>;
6346
+ export type WabaMessageTemplatesLazyQueryHookResult = ReturnType<typeof useWabaMessageTemplatesLazyQuery>;
6347
+ export type WabaMessageTemplatesSuspenseQueryHookResult = ReturnType<typeof useWabaMessageTemplatesSuspenseQuery>;
6348
+ export type WabaMessageTemplatesQueryResult = Apollo.QueryResult<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>;
6349
+ export declare function refetchWabaMessageTemplatesQuery(variables: WabaMessageTemplatesQueryVariables): {
6350
+ query: Apollo.DocumentNode;
6351
+ variables: Exact<{
6352
+ input: WabaMessageTemplatesInput;
6353
+ }>;
6354
+ };
6355
+ export declare const BulkDeleteClientsDocument: Apollo.DocumentNode;
6356
+ export type BulkDeleteClientsMutationFn = Apollo.MutationFunction<BulkDeleteClientsMutation, BulkDeleteClientsMutationVariables>;
5963
6357
  /**
5964
- * __useDeleteBroadcastMutation__
6358
+ * __useBulkDeleteClientsMutation__
5965
6359
  *
5966
- * To run a mutation, you first call `useDeleteBroadcastMutation` within a React component and pass it any options that fit your needs.
5967
- * When your component renders, `useDeleteBroadcastMutation` returns a tuple that includes:
6360
+ * To run a mutation, you first call `useBulkDeleteClientsMutation` within a React component and pass it any options that fit your needs.
6361
+ * When your component renders, `useBulkDeleteClientsMutation` returns a tuple that includes:
5968
6362
  * - A mutate function that you can call at any time to execute the mutation
5969
6363
  * - An object with fields that represent the current status of the mutation's execution
5970
6364
  *
5971
6365
  * @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;
5972
6366
  *
5973
6367
  * @example
5974
- * const [deleteBroadcastMutation, { data, loading, error }] = useDeleteBroadcastMutation({
6368
+ * const [bulkDeleteClientsMutation, { data, loading, error }] = useBulkDeleteClientsMutation({
5975
6369
  * variables: {
5976
6370
  * input: // value for 'input'
5977
6371
  * },
5978
6372
  * });
5979
6373
  */
5980
- export declare function useDeleteBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>): Apollo.MutationTuple<DeleteBroadcastMutation, Exact<{
5981
- input: BroadcastDeleteInput;
6374
+ export declare function useBulkDeleteClientsMutation(baseOptions?: Apollo.MutationHookOptions<BulkDeleteClientsMutation, BulkDeleteClientsMutationVariables>): Apollo.MutationTuple<BulkDeleteClientsMutation, Exact<{
6375
+ input: BulkPermanentDeleteClientsInput;
5982
6376
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
5983
- export type DeleteBroadcastMutationHookResult = ReturnType<typeof useDeleteBroadcastMutation>;
5984
- export type DeleteBroadcastMutationResult = Apollo.MutationResult<DeleteBroadcastMutation>;
5985
- export type DeleteBroadcastMutationOptions = Apollo.BaseMutationOptions<DeleteBroadcastMutation, DeleteBroadcastMutationVariables>;
5986
- export declare const DeleteClientDocument: Apollo.DocumentNode;
5987
- export type DeleteClientMutationFn = Apollo.MutationFunction<DeleteClientMutation, DeleteClientMutationVariables>;
6377
+ export type BulkDeleteClientsMutationHookResult = ReturnType<typeof useBulkDeleteClientsMutation>;
6378
+ export type BulkDeleteClientsMutationResult = Apollo.MutationResult<BulkDeleteClientsMutation>;
6379
+ export type BulkDeleteClientsMutationOptions = Apollo.BaseMutationOptions<BulkDeleteClientsMutation, BulkDeleteClientsMutationVariables>;
6380
+ export declare const BulkImportContactsDocument: Apollo.DocumentNode;
6381
+ export type BulkImportContactsMutationFn = Apollo.MutationFunction<BulkImportContactsMutation, BulkImportContactsMutationVariables>;
5988
6382
  /**
5989
- * __useDeleteClientMutation__
6383
+ * __useBulkImportContactsMutation__
5990
6384
  *
5991
- * To run a mutation, you first call `useDeleteClientMutation` within a React component and pass it any options that fit your needs.
5992
- * When your component renders, `useDeleteClientMutation` returns a tuple that includes:
6385
+ * To run a mutation, you first call `useBulkImportContactsMutation` within a React component and pass it any options that fit your needs.
6386
+ * When your component renders, `useBulkImportContactsMutation` returns a tuple that includes:
5993
6387
  * - A mutate function that you can call at any time to execute the mutation
5994
6388
  * - An object with fields that represent the current status of the mutation's execution
5995
6389
  *
5996
6390
  * @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;
5997
6391
  *
5998
6392
  * @example
5999
- * const [deleteClientMutation, { data, loading, error }] = useDeleteClientMutation({
6393
+ * const [bulkImportContactsMutation, { data, loading, error }] = useBulkImportContactsMutation({
6000
6394
  * variables: {
6001
6395
  * input: // value for 'input'
6002
6396
  * },
6003
6397
  * });
6004
6398
  */
6005
- export declare function useDeleteClientMutation(baseOptions?: Apollo.MutationHookOptions<DeleteClientMutation, DeleteClientMutationVariables>): Apollo.MutationTuple<DeleteClientMutation, Exact<{
6006
- input: ClientInput;
6399
+ export declare function useBulkImportContactsMutation(baseOptions?: Apollo.MutationHookOptions<BulkImportContactsMutation, BulkImportContactsMutationVariables>): Apollo.MutationTuple<BulkImportContactsMutation, Exact<{
6400
+ input: BulkImportContactsInput;
6007
6401
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6008
- export type DeleteClientMutationHookResult = ReturnType<typeof useDeleteClientMutation>;
6009
- export type DeleteClientMutationResult = Apollo.MutationResult<DeleteClientMutation>;
6010
- export type DeleteClientMutationOptions = Apollo.BaseMutationOptions<DeleteClientMutation, DeleteClientMutationVariables>;
6011
- export declare const DeleteClientByExternalIdDocument: Apollo.DocumentNode;
6012
- export type DeleteClientByExternalIdMutationFn = Apollo.MutationFunction<DeleteClientByExternalIdMutation, DeleteClientByExternalIdMutationVariables>;
6402
+ export type BulkImportContactsMutationHookResult = ReturnType<typeof useBulkImportContactsMutation>;
6403
+ export type BulkImportContactsMutationResult = Apollo.MutationResult<BulkImportContactsMutation>;
6404
+ export type BulkImportContactsMutationOptions = Apollo.BaseMutationOptions<BulkImportContactsMutation, BulkImportContactsMutationVariables>;
6405
+ export declare const BulkImportContactsJobStatusDocument: Apollo.DocumentNode;
6406
+ /**
6407
+ * __useBulkImportContactsJobStatusQuery__
6408
+ *
6409
+ * To run a query within a React component, call `useBulkImportContactsJobStatusQuery` and pass it any options that fit your needs.
6410
+ * When your component renders, `useBulkImportContactsJobStatusQuery` returns an object from Apollo Client that contains loading, error, and data properties
6411
+ * you can use to render your UI.
6412
+ *
6413
+ * @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;
6414
+ *
6415
+ * @example
6416
+ * const { data, loading, error } = useBulkImportContactsJobStatusQuery({
6417
+ * variables: {
6418
+ * input: // value for 'input'
6419
+ * },
6420
+ * });
6421
+ */
6422
+ export declare function useBulkImportContactsJobStatusQuery(baseOptions: Apollo.QueryHookOptions<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables> & ({
6423
+ variables: BulkImportContactsJobStatusQueryVariables;
6424
+ skip?: boolean;
6425
+ } | {
6426
+ skip: boolean;
6427
+ })): Apollo.QueryResult<BulkImportContactsJobStatusQuery, Exact<{
6428
+ input: BulkImportContactsJobStatusInput;
6429
+ }>>;
6430
+ export declare function useBulkImportContactsJobStatusLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables>): Apollo.LazyQueryResultTuple<BulkImportContactsJobStatusQuery, Exact<{
6431
+ input: BulkImportContactsJobStatusInput;
6432
+ }>>;
6433
+ export declare function useBulkImportContactsJobStatusSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables>): Apollo.UseSuspenseQueryResult<BulkImportContactsJobStatusQuery | undefined, Exact<{
6434
+ input: BulkImportContactsJobStatusInput;
6435
+ }>>;
6436
+ export type BulkImportContactsJobStatusQueryHookResult = ReturnType<typeof useBulkImportContactsJobStatusQuery>;
6437
+ export type BulkImportContactsJobStatusLazyQueryHookResult = ReturnType<typeof useBulkImportContactsJobStatusLazyQuery>;
6438
+ export type BulkImportContactsJobStatusSuspenseQueryHookResult = ReturnType<typeof useBulkImportContactsJobStatusSuspenseQuery>;
6439
+ export type BulkImportContactsJobStatusQueryResult = Apollo.QueryResult<BulkImportContactsJobStatusQuery, BulkImportContactsJobStatusQueryVariables>;
6440
+ export declare function refetchBulkImportContactsJobStatusQuery(variables: BulkImportContactsJobStatusQueryVariables): {
6441
+ query: Apollo.DocumentNode;
6442
+ variables: Exact<{
6443
+ input: BulkImportContactsJobStatusInput;
6444
+ }>;
6445
+ };
6446
+ export declare const BulkPermanentDeleteClientsDocument: Apollo.DocumentNode;
6447
+ export type BulkPermanentDeleteClientsMutationFn = Apollo.MutationFunction<BulkPermanentDeleteClientsMutation, BulkPermanentDeleteClientsMutationVariables>;
6013
6448
  /**
6014
- * __useDeleteClientByExternalIdMutation__
6449
+ * __useBulkPermanentDeleteClientsMutation__
6015
6450
  *
6016
- * To run a mutation, you first call `useDeleteClientByExternalIdMutation` within a React component and pass it any options that fit your needs.
6017
- * When your component renders, `useDeleteClientByExternalIdMutation` returns a tuple that includes:
6451
+ * To run a mutation, you first call `useBulkPermanentDeleteClientsMutation` within a React component and pass it any options that fit your needs.
6452
+ * When your component renders, `useBulkPermanentDeleteClientsMutation` returns a tuple that includes:
6018
6453
  * - A mutate function that you can call at any time to execute the mutation
6019
6454
  * - An object with fields that represent the current status of the mutation's execution
6020
6455
  *
6021
6456
  * @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;
6022
6457
  *
6023
6458
  * @example
6024
- * const [deleteClientByExternalIdMutation, { data, loading, error }] = useDeleteClientByExternalIdMutation({
6459
+ * const [bulkPermanentDeleteClientsMutation, { data, loading, error }] = useBulkPermanentDeleteClientsMutation({
6025
6460
  * variables: {
6026
6461
  * input: // value for 'input'
6027
6462
  * },
6028
6463
  * });
6029
6464
  */
6030
- export declare function useDeleteClientByExternalIdMutation(baseOptions?: Apollo.MutationHookOptions<DeleteClientByExternalIdMutation, DeleteClientByExternalIdMutationVariables>): Apollo.MutationTuple<DeleteClientByExternalIdMutation, Exact<{
6031
- input: ClientDeleteByExternalIdInput;
6465
+ export declare function useBulkPermanentDeleteClientsMutation(baseOptions?: Apollo.MutationHookOptions<BulkPermanentDeleteClientsMutation, BulkPermanentDeleteClientsMutationVariables>): Apollo.MutationTuple<BulkPermanentDeleteClientsMutation, Exact<{
6466
+ input: BulkPermanentDeleteClientsInput;
6032
6467
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6033
- export type DeleteClientByExternalIdMutationHookResult = ReturnType<typeof useDeleteClientByExternalIdMutation>;
6034
- export type DeleteClientByExternalIdMutationResult = Apollo.MutationResult<DeleteClientByExternalIdMutation>;
6035
- export type DeleteClientByExternalIdMutationOptions = Apollo.BaseMutationOptions<DeleteClientByExternalIdMutation, DeleteClientByExternalIdMutationVariables>;
6036
- export declare const EndConvDocument: Apollo.DocumentNode;
6037
- export type EndConvMutationFn = Apollo.MutationFunction<EndConvMutation, EndConvMutationVariables>;
6468
+ export type BulkPermanentDeleteClientsMutationHookResult = ReturnType<typeof useBulkPermanentDeleteClientsMutation>;
6469
+ export type BulkPermanentDeleteClientsMutationResult = Apollo.MutationResult<BulkPermanentDeleteClientsMutation>;
6470
+ export type BulkPermanentDeleteClientsMutationOptions = Apollo.BaseMutationOptions<BulkPermanentDeleteClientsMutation, BulkPermanentDeleteClientsMutationVariables>;
6471
+ export declare const BulkPermanentDeleteClientsByFilterDocument: Apollo.DocumentNode;
6472
+ export type BulkPermanentDeleteClientsByFilterMutationFn = Apollo.MutationFunction<BulkPermanentDeleteClientsByFilterMutation, BulkPermanentDeleteClientsByFilterMutationVariables>;
6038
6473
  /**
6039
- * __useEndConvMutation__
6474
+ * __useBulkPermanentDeleteClientsByFilterMutation__
6040
6475
  *
6041
- * To run a mutation, you first call `useEndConvMutation` within a React component and pass it any options that fit your needs.
6042
- * When your component renders, `useEndConvMutation` returns a tuple that includes:
6476
+ * To run a mutation, you first call `useBulkPermanentDeleteClientsByFilterMutation` within a React component and pass it any options that fit your needs.
6477
+ * When your component renders, `useBulkPermanentDeleteClientsByFilterMutation` returns a tuple that includes:
6043
6478
  * - A mutate function that you can call at any time to execute the mutation
6044
6479
  * - An object with fields that represent the current status of the mutation's execution
6045
6480
  *
6046
6481
  * @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;
6047
6482
  *
6048
6483
  * @example
6049
- * const [endConvMutation, { data, loading, error }] = useEndConvMutation({
6484
+ * const [bulkPermanentDeleteClientsByFilterMutation, { data, loading, error }] = useBulkPermanentDeleteClientsByFilterMutation({
6050
6485
  * variables: {
6051
6486
  * input: // value for 'input'
6052
6487
  * },
6053
6488
  * });
6054
6489
  */
6055
- export declare function useEndConvMutation(baseOptions?: Apollo.MutationHookOptions<EndConvMutation, EndConvMutationVariables>): Apollo.MutationTuple<EndConvMutation, Exact<{
6056
- input: ConvEndInput;
6490
+ export declare function useBulkPermanentDeleteClientsByFilterMutation(baseOptions?: Apollo.MutationHookOptions<BulkPermanentDeleteClientsByFilterMutation, BulkPermanentDeleteClientsByFilterMutationVariables>): Apollo.MutationTuple<BulkPermanentDeleteClientsByFilterMutation, Exact<{
6491
+ input: BulkPermanentDeleteClientsByFilterInput;
6057
6492
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6058
- export type EndConvMutationHookResult = ReturnType<typeof useEndConvMutation>;
6059
- export type EndConvMutationResult = Apollo.MutationResult<EndConvMutation>;
6060
- export type EndConvMutationOptions = Apollo.BaseMutationOptions<EndConvMutation, EndConvMutationVariables>;
6061
- export declare const LaunchBroadcastDocument: Apollo.DocumentNode;
6062
- export type LaunchBroadcastMutationFn = Apollo.MutationFunction<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>;
6493
+ export type BulkPermanentDeleteClientsByFilterMutationHookResult = ReturnType<typeof useBulkPermanentDeleteClientsByFilterMutation>;
6494
+ export type BulkPermanentDeleteClientsByFilterMutationResult = Apollo.MutationResult<BulkPermanentDeleteClientsByFilterMutation>;
6495
+ export type BulkPermanentDeleteClientsByFilterMutationOptions = Apollo.BaseMutationOptions<BulkPermanentDeleteClientsByFilterMutation, BulkPermanentDeleteClientsByFilterMutationVariables>;
6496
+ export declare const BulkUndeleteClientsDocument: Apollo.DocumentNode;
6497
+ export type BulkUndeleteClientsMutationFn = Apollo.MutationFunction<BulkUndeleteClientsMutation, BulkUndeleteClientsMutationVariables>;
6063
6498
  /**
6064
- * __useLaunchBroadcastMutation__
6499
+ * __useBulkUndeleteClientsMutation__
6065
6500
  *
6066
- * To run a mutation, you first call `useLaunchBroadcastMutation` within a React component and pass it any options that fit your needs.
6067
- * When your component renders, `useLaunchBroadcastMutation` returns a tuple that includes:
6501
+ * To run a mutation, you first call `useBulkUndeleteClientsMutation` within a React component and pass it any options that fit your needs.
6502
+ * When your component renders, `useBulkUndeleteClientsMutation` returns a tuple that includes:
6068
6503
  * - A mutate function that you can call at any time to execute the mutation
6069
6504
  * - An object with fields that represent the current status of the mutation's execution
6070
6505
  *
6071
6506
  * @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;
6072
6507
  *
6073
6508
  * @example
6074
- * const [launchBroadcastMutation, { data, loading, error }] = useLaunchBroadcastMutation({
6509
+ * const [bulkUndeleteClientsMutation, { data, loading, error }] = useBulkUndeleteClientsMutation({
6075
6510
  * variables: {
6076
6511
  * input: // value for 'input'
6077
6512
  * },
6078
6513
  * });
6079
6514
  */
6080
- export declare function useLaunchBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>): Apollo.MutationTuple<LaunchBroadcastMutation, Exact<{
6081
- input: BroadcastLaunchInput;
6515
+ export declare function useBulkUndeleteClientsMutation(baseOptions?: Apollo.MutationHookOptions<BulkUndeleteClientsMutation, BulkUndeleteClientsMutationVariables>): Apollo.MutationTuple<BulkUndeleteClientsMutation, Exact<{
6516
+ input: BulkPermanentDeleteClientsInput;
6082
6517
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6083
- export type LaunchBroadcastMutationHookResult = ReturnType<typeof useLaunchBroadcastMutation>;
6084
- export type LaunchBroadcastMutationResult = Apollo.MutationResult<LaunchBroadcastMutation>;
6085
- export type LaunchBroadcastMutationOptions = Apollo.BaseMutationOptions<LaunchBroadcastMutation, LaunchBroadcastMutationVariables>;
6086
- export declare const MessagesDocument: Apollo.DocumentNode;
6518
+ export type BulkUndeleteClientsMutationHookResult = ReturnType<typeof useBulkUndeleteClientsMutation>;
6519
+ export type BulkUndeleteClientsMutationResult = Apollo.MutationResult<BulkUndeleteClientsMutation>;
6520
+ export type BulkUndeleteClientsMutationOptions = Apollo.BaseMutationOptions<BulkUndeleteClientsMutation, BulkUndeleteClientsMutationVariables>;
6521
+ export declare const ClientDocument: Apollo.DocumentNode;
6087
6522
  /**
6088
- * __useMessagesQuery__
6523
+ * __useClientQuery__
6089
6524
  *
6090
- * To run a query within a React component, call `useMessagesQuery` and pass it any options that fit your needs.
6091
- * When your component renders, `useMessagesQuery` returns an object from Apollo Client that contains loading, error, and data properties
6525
+ * To run a query within a React component, call `useClientQuery` and pass it any options that fit your needs.
6526
+ * When your component renders, `useClientQuery` returns an object from Apollo Client that contains loading, error, and data properties
6092
6527
  * you can use to render your UI.
6093
6528
  *
6094
6529
  * @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;
6095
6530
  *
6096
6531
  * @example
6097
- * const { data, loading, error } = useMessagesQuery({
6532
+ * const { data, loading, error } = useClientQuery({
6098
6533
  * variables: {
6099
6534
  * input: // value for 'input'
6100
- * pageInfo: // value for 'pageInfo'
6101
6535
  * },
6102
6536
  * });
6103
6537
  */
6104
- export declare function useMessagesQuery(baseOptions: Apollo.QueryHookOptions<MessagesQuery, MessagesQueryVariables> & ({
6105
- variables: MessagesQueryVariables;
6538
+ export declare function useClientQuery(baseOptions: Apollo.QueryHookOptions<ClientQuery, ClientQueryVariables> & ({
6539
+ variables: ClientQueryVariables;
6106
6540
  skip?: boolean;
6107
6541
  } | {
6108
6542
  skip: boolean;
6109
- })): Apollo.QueryResult<MessagesQuery, Exact<{
6110
- input: MessagesInput;
6111
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6543
+ })): Apollo.QueryResult<ClientQuery, Exact<{
6544
+ input: ClientInput;
6112
6545
  }>>;
6113
- export declare function useMessagesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<MessagesQuery, MessagesQueryVariables>): Apollo.LazyQueryResultTuple<MessagesQuery, Exact<{
6114
- input: MessagesInput;
6115
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6546
+ export declare function useClientLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientQuery, ClientQueryVariables>): Apollo.LazyQueryResultTuple<ClientQuery, Exact<{
6547
+ input: ClientInput;
6116
6548
  }>>;
6117
- export declare function useMessagesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<MessagesQuery, MessagesQueryVariables>): Apollo.UseSuspenseQueryResult<MessagesQuery | undefined, Exact<{
6118
- input: MessagesInput;
6119
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6549
+ export declare function useClientSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientQuery, ClientQueryVariables>): Apollo.UseSuspenseQueryResult<ClientQuery | undefined, Exact<{
6550
+ input: ClientInput;
6120
6551
  }>>;
6121
- export type MessagesQueryHookResult = ReturnType<typeof useMessagesQuery>;
6122
- export type MessagesLazyQueryHookResult = ReturnType<typeof useMessagesLazyQuery>;
6123
- export type MessagesSuspenseQueryHookResult = ReturnType<typeof useMessagesSuspenseQuery>;
6124
- export type MessagesQueryResult = Apollo.QueryResult<MessagesQuery, MessagesQueryVariables>;
6125
- export declare function refetchMessagesQuery(variables: MessagesQueryVariables): {
6552
+ export type ClientQueryHookResult = ReturnType<typeof useClientQuery>;
6553
+ export type ClientLazyQueryHookResult = ReturnType<typeof useClientLazyQuery>;
6554
+ export type ClientSuspenseQueryHookResult = ReturnType<typeof useClientSuspenseQuery>;
6555
+ export type ClientQueryResult = Apollo.QueryResult<ClientQuery, ClientQueryVariables>;
6556
+ export declare function refetchClientQuery(variables: ClientQueryVariables): {
6126
6557
  query: Apollo.DocumentNode;
6127
6558
  variables: Exact<{
6128
- input: MessagesInput;
6129
- pageInfo?: InputMaybe<PageInfoInput> | undefined;
6559
+ input: ClientInput;
6130
6560
  }>;
6131
6561
  };
6132
- export declare const OpenConversationsNeedResponseCountDocument: Apollo.DocumentNode;
6562
+ export declare const ClientByPhoneDocument: Apollo.DocumentNode;
6133
6563
  /**
6134
- * __useOpenConversationsNeedResponseCountQuery__
6564
+ * __useClientByPhoneQuery__
6135
6565
  *
6136
- * To run a query within a React component, call `useOpenConversationsNeedResponseCountQuery` and pass it any options that fit your needs.
6137
- * When your component renders, `useOpenConversationsNeedResponseCountQuery` returns an object from Apollo Client that contains loading, error, and data properties
6566
+ * To run a query within a React component, call `useClientByPhoneQuery` and pass it any options that fit your needs.
6567
+ * When your component renders, `useClientByPhoneQuery` returns an object from Apollo Client that contains loading, error, and data properties
6138
6568
  * you can use to render your UI.
6139
6569
  *
6140
6570
  * @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;
6141
6571
  *
6142
6572
  * @example
6143
- * const { data, loading, error } = useOpenConversationsNeedResponseCountQuery({
6573
+ * const { data, loading, error } = useClientByPhoneQuery({
6144
6574
  * variables: {
6145
6575
  * input: // value for 'input'
6146
6576
  * },
6147
6577
  * });
6148
6578
  */
6149
- export declare function useOpenConversationsNeedResponseCountQuery(baseOptions: Apollo.QueryHookOptions<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables> & ({
6150
- variables: OpenConversationsNeedResponseCountQueryVariables;
6579
+ export declare function useClientByPhoneQuery(baseOptions: Apollo.QueryHookOptions<ClientByPhoneQuery, ClientByPhoneQueryVariables> & ({
6580
+ variables: ClientByPhoneQueryVariables;
6151
6581
  skip?: boolean;
6152
6582
  } | {
6153
6583
  skip: boolean;
6154
- })): Apollo.QueryResult<OpenConversationsNeedResponseCountQuery, Exact<{
6155
- input: OpenConversationsNeedResponseInput;
6584
+ })): Apollo.QueryResult<ClientByPhoneQuery, Exact<{
6585
+ input: ClientByPhoneInput;
6156
6586
  }>>;
6157
- export declare function useOpenConversationsNeedResponseCountLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables>): Apollo.LazyQueryResultTuple<OpenConversationsNeedResponseCountQuery, Exact<{
6158
- input: OpenConversationsNeedResponseInput;
6587
+ export declare function useClientByPhoneLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientByPhoneQuery, ClientByPhoneQueryVariables>): Apollo.LazyQueryResultTuple<ClientByPhoneQuery, Exact<{
6588
+ input: ClientByPhoneInput;
6159
6589
  }>>;
6160
- export declare function useOpenConversationsNeedResponseCountSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables>): Apollo.UseSuspenseQueryResult<OpenConversationsNeedResponseCountQuery | undefined, Exact<{
6161
- input: OpenConversationsNeedResponseInput;
6590
+ export declare function useClientByPhoneSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientByPhoneQuery, ClientByPhoneQueryVariables>): Apollo.UseSuspenseQueryResult<ClientByPhoneQuery | undefined, Exact<{
6591
+ input: ClientByPhoneInput;
6162
6592
  }>>;
6163
- export type OpenConversationsNeedResponseCountQueryHookResult = ReturnType<typeof useOpenConversationsNeedResponseCountQuery>;
6164
- export type OpenConversationsNeedResponseCountLazyQueryHookResult = ReturnType<typeof useOpenConversationsNeedResponseCountLazyQuery>;
6165
- export type OpenConversationsNeedResponseCountSuspenseQueryHookResult = ReturnType<typeof useOpenConversationsNeedResponseCountSuspenseQuery>;
6166
- export type OpenConversationsNeedResponseCountQueryResult = Apollo.QueryResult<OpenConversationsNeedResponseCountQuery, OpenConversationsNeedResponseCountQueryVariables>;
6167
- export declare function refetchOpenConversationsNeedResponseCountQuery(variables: OpenConversationsNeedResponseCountQueryVariables): {
6593
+ export type ClientByPhoneQueryHookResult = ReturnType<typeof useClientByPhoneQuery>;
6594
+ export type ClientByPhoneLazyQueryHookResult = ReturnType<typeof useClientByPhoneLazyQuery>;
6595
+ export type ClientByPhoneSuspenseQueryHookResult = ReturnType<typeof useClientByPhoneSuspenseQuery>;
6596
+ export type ClientByPhoneQueryResult = Apollo.QueryResult<ClientByPhoneQuery, ClientByPhoneQueryVariables>;
6597
+ export declare function refetchClientByPhoneQuery(variables: ClientByPhoneQueryVariables): {
6168
6598
  query: Apollo.DocumentNode;
6169
6599
  variables: Exact<{
6170
- input: OpenConversationsNeedResponseInput;
6600
+ input: ClientByPhoneInput;
6171
6601
  }>;
6172
6602
  };
6173
- export declare const PatchAgentDocument: Apollo.DocumentNode;
6174
- export type PatchAgentMutationFn = Apollo.MutationFunction<PatchAgentMutation, PatchAgentMutationVariables>;
6175
- /**
6176
- * __usePatchAgentMutation__
6177
- *
6178
- * To run a mutation, you first call `usePatchAgentMutation` within a React component and pass it any options that fit your needs.
6179
- * When your component renders, `usePatchAgentMutation` returns a tuple that includes:
6180
- * - A mutate function that you can call at any time to execute the mutation
6181
- * - An object with fields that represent the current status of the mutation's execution
6182
- *
6183
- * @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;
6184
- *
6185
- * @example
6186
- * const [patchAgentMutation, { data, loading, error }] = usePatchAgentMutation({
6187
- * variables: {
6188
- * input: // value for 'input'
6189
- * },
6190
- * });
6191
- */
6192
- export declare function usePatchAgentMutation(baseOptions?: Apollo.MutationHookOptions<PatchAgentMutation, PatchAgentMutationVariables>): Apollo.MutationTuple<PatchAgentMutation, Exact<{
6193
- input: AgentPatchInput;
6194
- }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6195
- export type PatchAgentMutationHookResult = ReturnType<typeof usePatchAgentMutation>;
6196
- export type PatchAgentMutationResult = Apollo.MutationResult<PatchAgentMutation>;
6197
- export type PatchAgentMutationOptions = Apollo.BaseMutationOptions<PatchAgentMutation, PatchAgentMutationVariables>;
6198
- export declare const PatchBroadcastDocument: Apollo.DocumentNode;
6199
- export type PatchBroadcastMutationFn = Apollo.MutationFunction<PatchBroadcastMutation, PatchBroadcastMutationVariables>;
6200
- /**
6201
- * __usePatchBroadcastMutation__
6202
- *
6203
- * To run a mutation, you first call `usePatchBroadcastMutation` within a React component and pass it any options that fit your needs.
6204
- * When your component renders, `usePatchBroadcastMutation` returns a tuple that includes:
6205
- * - A mutate function that you can call at any time to execute the mutation
6206
- * - An object with fields that represent the current status of the mutation's execution
6207
- *
6208
- * @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;
6209
- *
6210
- * @example
6211
- * const [patchBroadcastMutation, { data, loading, error }] = usePatchBroadcastMutation({
6212
- * variables: {
6213
- * input: // value for 'input'
6214
- * },
6215
- * });
6216
- */
6217
- export declare function usePatchBroadcastMutation(baseOptions?: Apollo.MutationHookOptions<PatchBroadcastMutation, PatchBroadcastMutationVariables>): Apollo.MutationTuple<PatchBroadcastMutation, Exact<{
6218
- input: BroadcastPatchInput;
6219
- }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6220
- export type PatchBroadcastMutationHookResult = ReturnType<typeof usePatchBroadcastMutation>;
6221
- export type PatchBroadcastMutationResult = Apollo.MutationResult<PatchBroadcastMutation>;
6222
- export type PatchBroadcastMutationOptions = Apollo.BaseMutationOptions<PatchBroadcastMutation, PatchBroadcastMutationVariables>;
6223
- export declare const PatchClientDocument: Apollo.DocumentNode;
6224
- export type PatchClientMutationFn = Apollo.MutationFunction<PatchClientMutation, PatchClientMutationVariables>;
6603
+ export declare const ClientsDocument: Apollo.DocumentNode;
6225
6604
  /**
6226
- * __usePatchClientMutation__
6605
+ * __useClientsQuery__
6227
6606
  *
6228
- * To run a mutation, you first call `usePatchClientMutation` within a React component and pass it any options that fit your needs.
6229
- * When your component renders, `usePatchClientMutation` returns a tuple that includes:
6230
- * - A mutate function that you can call at any time to execute the mutation
6231
- * - An object with fields that represent the current status of the mutation's execution
6607
+ * To run a query within a React component, call `useClientsQuery` and pass it any options that fit your needs.
6608
+ * When your component renders, `useClientsQuery` returns an object from Apollo Client that contains loading, error, and data properties
6609
+ * you can use to render your UI.
6232
6610
  *
6233
- * @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;
6611
+ * @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;
6234
6612
  *
6235
6613
  * @example
6236
- * const [patchClientMutation, { data, loading, error }] = usePatchClientMutation({
6614
+ * const { data, loading, error } = useClientsQuery({
6237
6615
  * variables: {
6238
6616
  * input: // value for 'input'
6617
+ * pageInfo: // value for 'pageInfo'
6239
6618
  * },
6240
6619
  * });
6241
6620
  */
6242
- export declare function usePatchClientMutation(baseOptions?: Apollo.MutationHookOptions<PatchClientMutation, PatchClientMutationVariables>): Apollo.MutationTuple<PatchClientMutation, Exact<{
6243
- input: ClientPatchInput;
6244
- }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6245
- export type PatchClientMutationHookResult = ReturnType<typeof usePatchClientMutation>;
6246
- export type PatchClientMutationResult = Apollo.MutationResult<PatchClientMutation>;
6247
- export type PatchClientMutationOptions = Apollo.BaseMutationOptions<PatchClientMutation, PatchClientMutationVariables>;
6248
- export declare const PatchConvDocument: Apollo.DocumentNode;
6249
- export type PatchConvMutationFn = Apollo.MutationFunction<PatchConvMutation, PatchConvMutationVariables>;
6621
+ export declare function useClientsQuery(baseOptions: Apollo.QueryHookOptions<ClientsQuery, ClientsQueryVariables> & ({
6622
+ variables: ClientsQueryVariables;
6623
+ skip?: boolean;
6624
+ } | {
6625
+ skip: boolean;
6626
+ })): Apollo.QueryResult<ClientsQuery, Exact<{
6627
+ input: ClientsInput;
6628
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
6629
+ }>>;
6630
+ export declare function useClientsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ClientsQuery, ClientsQueryVariables>): Apollo.LazyQueryResultTuple<ClientsQuery, Exact<{
6631
+ input: ClientsInput;
6632
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
6633
+ }>>;
6634
+ export declare function useClientsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<ClientsQuery, ClientsQueryVariables>): Apollo.UseSuspenseQueryResult<ClientsQuery | undefined, Exact<{
6635
+ input: ClientsInput;
6636
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
6637
+ }>>;
6638
+ export type ClientsQueryHookResult = ReturnType<typeof useClientsQuery>;
6639
+ export type ClientsLazyQueryHookResult = ReturnType<typeof useClientsLazyQuery>;
6640
+ export type ClientsSuspenseQueryHookResult = ReturnType<typeof useClientsSuspenseQuery>;
6641
+ export type ClientsQueryResult = Apollo.QueryResult<ClientsQuery, ClientsQueryVariables>;
6642
+ export declare function refetchClientsQuery(variables: ClientsQueryVariables): {
6643
+ query: Apollo.DocumentNode;
6644
+ variables: Exact<{
6645
+ input: ClientsInput;
6646
+ pageInfo?: InputMaybe<PageInfoInput> | undefined;
6647
+ }>;
6648
+ };
6649
+ export declare const CreateClientDocument: Apollo.DocumentNode;
6650
+ export type CreateClientMutationFn = Apollo.MutationFunction<CreateClientMutation, CreateClientMutationVariables>;
6250
6651
  /**
6251
- * __usePatchConvMutation__
6652
+ * __useCreateClientMutation__
6252
6653
  *
6253
- * To run a mutation, you first call `usePatchConvMutation` within a React component and pass it any options that fit your needs.
6254
- * When your component renders, `usePatchConvMutation` returns a tuple that includes:
6654
+ * To run a mutation, you first call `useCreateClientMutation` within a React component and pass it any options that fit your needs.
6655
+ * When your component renders, `useCreateClientMutation` returns a tuple that includes:
6255
6656
  * - A mutate function that you can call at any time to execute the mutation
6256
6657
  * - An object with fields that represent the current status of the mutation's execution
6257
6658
  *
6258
6659
  * @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;
6259
6660
  *
6260
6661
  * @example
6261
- * const [patchConvMutation, { data, loading, error }] = usePatchConvMutation({
6662
+ * const [createClientMutation, { data, loading, error }] = useCreateClientMutation({
6262
6663
  * variables: {
6263
6664
  * input: // value for 'input'
6264
6665
  * },
6265
6666
  * });
6266
6667
  */
6267
- export declare function usePatchConvMutation(baseOptions?: Apollo.MutationHookOptions<PatchConvMutation, PatchConvMutationVariables>): Apollo.MutationTuple<PatchConvMutation, Exact<{
6268
- input: ConvPatchInput;
6668
+ export declare function useCreateClientMutation(baseOptions?: Apollo.MutationHookOptions<CreateClientMutation, CreateClientMutationVariables>): Apollo.MutationTuple<CreateClientMutation, Exact<{
6669
+ input: ClientCreateInput;
6269
6670
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6270
- export type PatchConvMutationHookResult = ReturnType<typeof usePatchConvMutation>;
6271
- export type PatchConvMutationResult = Apollo.MutationResult<PatchConvMutation>;
6272
- export type PatchConvMutationOptions = Apollo.BaseMutationOptions<PatchConvMutation, PatchConvMutationVariables>;
6273
- export declare const StartConvDocument: Apollo.DocumentNode;
6274
- export type StartConvMutationFn = Apollo.MutationFunction<StartConvMutation, StartConvMutationVariables>;
6671
+ export type CreateClientMutationHookResult = ReturnType<typeof useCreateClientMutation>;
6672
+ export type CreateClientMutationResult = Apollo.MutationResult<CreateClientMutation>;
6673
+ export type CreateClientMutationOptions = Apollo.BaseMutationOptions<CreateClientMutation, CreateClientMutationVariables>;
6674
+ export declare const DeleteClientDocument: Apollo.DocumentNode;
6675
+ export type DeleteClientMutationFn = Apollo.MutationFunction<DeleteClientMutation, DeleteClientMutationVariables>;
6275
6676
  /**
6276
- * __useStartConvMutation__
6677
+ * __useDeleteClientMutation__
6277
6678
  *
6278
- * To run a mutation, you first call `useStartConvMutation` within a React component and pass it any options that fit your needs.
6279
- * When your component renders, `useStartConvMutation` returns a tuple that includes:
6679
+ * To run a mutation, you first call `useDeleteClientMutation` within a React component and pass it any options that fit your needs.
6680
+ * When your component renders, `useDeleteClientMutation` returns a tuple that includes:
6280
6681
  * - A mutate function that you can call at any time to execute the mutation
6281
6682
  * - An object with fields that represent the current status of the mutation's execution
6282
6683
  *
6283
6684
  * @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;
6284
6685
  *
6285
6686
  * @example
6286
- * const [startConvMutation, { data, loading, error }] = useStartConvMutation({
6687
+ * const [deleteClientMutation, { data, loading, error }] = useDeleteClientMutation({
6287
6688
  * variables: {
6288
6689
  * input: // value for 'input'
6289
6690
  * },
6290
6691
  * });
6291
6692
  */
6292
- export declare function useStartConvMutation(baseOptions?: Apollo.MutationHookOptions<StartConvMutation, StartConvMutationVariables>): Apollo.MutationTuple<StartConvMutation, Exact<{
6293
- input: ConvStartInput;
6693
+ export declare function useDeleteClientMutation(baseOptions?: Apollo.MutationHookOptions<DeleteClientMutation, DeleteClientMutationVariables>): Apollo.MutationTuple<DeleteClientMutation, Exact<{
6694
+ input: ClientInput;
6294
6695
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6295
- export type StartConvMutationHookResult = ReturnType<typeof useStartConvMutation>;
6296
- export type StartConvMutationResult = Apollo.MutationResult<StartConvMutation>;
6297
- export type StartConvMutationOptions = Apollo.BaseMutationOptions<StartConvMutation, StartConvMutationVariables>;
6298
- export declare const TagClientDocument: Apollo.DocumentNode;
6299
- export type TagClientMutationFn = Apollo.MutationFunction<TagClientMutation, TagClientMutationVariables>;
6696
+ export type DeleteClientMutationHookResult = ReturnType<typeof useDeleteClientMutation>;
6697
+ export type DeleteClientMutationResult = Apollo.MutationResult<DeleteClientMutation>;
6698
+ export type DeleteClientMutationOptions = Apollo.BaseMutationOptions<DeleteClientMutation, DeleteClientMutationVariables>;
6699
+ export declare const DeleteClientByExternalIdDocument: Apollo.DocumentNode;
6700
+ export type DeleteClientByExternalIdMutationFn = Apollo.MutationFunction<DeleteClientByExternalIdMutation, DeleteClientByExternalIdMutationVariables>;
6300
6701
  /**
6301
- * __useTagClientMutation__
6702
+ * __useDeleteClientByExternalIdMutation__
6302
6703
  *
6303
- * To run a mutation, you first call `useTagClientMutation` within a React component and pass it any options that fit your needs.
6304
- * When your component renders, `useTagClientMutation` returns a tuple that includes:
6704
+ * To run a mutation, you first call `useDeleteClientByExternalIdMutation` within a React component and pass it any options that fit your needs.
6705
+ * When your component renders, `useDeleteClientByExternalIdMutation` returns a tuple that includes:
6305
6706
  * - A mutate function that you can call at any time to execute the mutation
6306
6707
  * - An object with fields that represent the current status of the mutation's execution
6307
6708
  *
6308
6709
  * @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;
6309
6710
  *
6310
6711
  * @example
6311
- * const [tagClientMutation, { data, loading, error }] = useTagClientMutation({
6712
+ * const [deleteClientByExternalIdMutation, { data, loading, error }] = useDeleteClientByExternalIdMutation({
6312
6713
  * variables: {
6313
6714
  * input: // value for 'input'
6314
6715
  * },
6315
6716
  * });
6316
6717
  */
6317
- export declare function useTagClientMutation(baseOptions?: Apollo.MutationHookOptions<TagClientMutation, TagClientMutationVariables>): Apollo.MutationTuple<TagClientMutation, Exact<{
6318
- input: ClientTagInput;
6718
+ export declare function useDeleteClientByExternalIdMutation(baseOptions?: Apollo.MutationHookOptions<DeleteClientByExternalIdMutation, DeleteClientByExternalIdMutationVariables>): Apollo.MutationTuple<DeleteClientByExternalIdMutation, Exact<{
6719
+ input: ClientDeleteByExternalIdInput;
6319
6720
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6320
- export type TagClientMutationHookResult = ReturnType<typeof useTagClientMutation>;
6321
- export type TagClientMutationResult = Apollo.MutationResult<TagClientMutation>;
6322
- export type TagClientMutationOptions = Apollo.BaseMutationOptions<TagClientMutation, TagClientMutationVariables>;
6323
- export declare const TagConvDocument: Apollo.DocumentNode;
6324
- export type TagConvMutationFn = Apollo.MutationFunction<TagConvMutation, TagConvMutationVariables>;
6721
+ export type DeleteClientByExternalIdMutationHookResult = ReturnType<typeof useDeleteClientByExternalIdMutation>;
6722
+ export type DeleteClientByExternalIdMutationResult = Apollo.MutationResult<DeleteClientByExternalIdMutation>;
6723
+ export type DeleteClientByExternalIdMutationOptions = Apollo.BaseMutationOptions<DeleteClientByExternalIdMutation, DeleteClientByExternalIdMutationVariables>;
6724
+ export declare const PatchClientDocument: Apollo.DocumentNode;
6725
+ export type PatchClientMutationFn = Apollo.MutationFunction<PatchClientMutation, PatchClientMutationVariables>;
6325
6726
  /**
6326
- * __useTagConvMutation__
6727
+ * __usePatchClientMutation__
6327
6728
  *
6328
- * To run a mutation, you first call `useTagConvMutation` within a React component and pass it any options that fit your needs.
6329
- * When your component renders, `useTagConvMutation` returns a tuple that includes:
6729
+ * To run a mutation, you first call `usePatchClientMutation` within a React component and pass it any options that fit your needs.
6730
+ * When your component renders, `usePatchClientMutation` returns a tuple that includes:
6330
6731
  * - A mutate function that you can call at any time to execute the mutation
6331
6732
  * - An object with fields that represent the current status of the mutation's execution
6332
6733
  *
6333
6734
  * @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;
6334
6735
  *
6335
6736
  * @example
6336
- * const [tagConvMutation, { data, loading, error }] = useTagConvMutation({
6737
+ * const [patchClientMutation, { data, loading, error }] = usePatchClientMutation({
6337
6738
  * variables: {
6338
6739
  * input: // value for 'input'
6339
6740
  * },
6340
6741
  * });
6341
6742
  */
6342
- export declare function useTagConvMutation(baseOptions?: Apollo.MutationHookOptions<TagConvMutation, TagConvMutationVariables>): Apollo.MutationTuple<TagConvMutation, Exact<{
6343
- input: ConvTagInput;
6743
+ export declare function usePatchClientMutation(baseOptions?: Apollo.MutationHookOptions<PatchClientMutation, PatchClientMutationVariables>): Apollo.MutationTuple<PatchClientMutation, Exact<{
6744
+ input: ClientPatchInput;
6344
6745
  }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6345
- export type TagConvMutationHookResult = ReturnType<typeof useTagConvMutation>;
6346
- export type TagConvMutationResult = Apollo.MutationResult<TagConvMutation>;
6347
- export type TagConvMutationOptions = Apollo.BaseMutationOptions<TagConvMutation, TagConvMutationVariables>;
6348
- export declare const TagsDocument: Apollo.DocumentNode;
6349
- /**
6350
- * __useTagsQuery__
6351
- *
6352
- * To run a query within a React component, call `useTagsQuery` and pass it any options that fit your needs.
6353
- * When your component renders, `useTagsQuery` returns an object from Apollo Client that contains loading, error, and data properties
6354
- * you can use to render your UI.
6355
- *
6356
- * @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;
6357
- *
6358
- * @example
6359
- * const { data, loading, error } = useTagsQuery({
6360
- * variables: {
6361
- * input: // value for 'input'
6362
- * },
6363
- * });
6364
- */
6365
- export declare function useTagsQuery(baseOptions: Apollo.QueryHookOptions<TagsQuery, TagsQueryVariables> & ({
6366
- variables: TagsQueryVariables;
6367
- skip?: boolean;
6368
- } | {
6369
- skip: boolean;
6370
- })): Apollo.QueryResult<TagsQuery, Exact<{
6371
- input: TagsInput;
6372
- }>>;
6373
- export declare function useTagsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TagsQuery, TagsQueryVariables>): Apollo.LazyQueryResultTuple<TagsQuery, Exact<{
6374
- input: TagsInput;
6375
- }>>;
6376
- export declare function useTagsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<TagsQuery, TagsQueryVariables>): Apollo.UseSuspenseQueryResult<TagsQuery | undefined, Exact<{
6377
- input: TagsInput;
6378
- }>>;
6379
- export type TagsQueryHookResult = ReturnType<typeof useTagsQuery>;
6380
- export type TagsLazyQueryHookResult = ReturnType<typeof useTagsLazyQuery>;
6381
- export type TagsSuspenseQueryHookResult = ReturnType<typeof useTagsSuspenseQuery>;
6382
- export type TagsQueryResult = Apollo.QueryResult<TagsQuery, TagsQueryVariables>;
6383
- export declare function refetchTagsQuery(variables: TagsQueryVariables): {
6384
- query: Apollo.DocumentNode;
6385
- variables: Exact<{
6386
- input: TagsInput;
6387
- }>;
6388
- };
6746
+ export type PatchClientMutationHookResult = ReturnType<typeof usePatchClientMutation>;
6747
+ export type PatchClientMutationResult = Apollo.MutationResult<PatchClientMutation>;
6748
+ export type PatchClientMutationOptions = Apollo.BaseMutationOptions<PatchClientMutation, PatchClientMutationVariables>;
6389
6749
  export declare const UndeleteClientDocument: Apollo.DocumentNode;
6390
6750
  export type UndeleteClientMutationFn = Apollo.MutationFunction<UndeleteClientMutation, UndeleteClientMutationVariables>;
6391
6751
  /**
@@ -6436,56 +6796,6 @@ export declare function useUndeleteClientByExternalIdMutation(baseOptions?: Apol
6436
6796
  export type UndeleteClientByExternalIdMutationHookResult = ReturnType<typeof useUndeleteClientByExternalIdMutation>;
6437
6797
  export type UndeleteClientByExternalIdMutationResult = Apollo.MutationResult<UndeleteClientByExternalIdMutation>;
6438
6798
  export type UndeleteClientByExternalIdMutationOptions = Apollo.BaseMutationOptions<UndeleteClientByExternalIdMutation, UndeleteClientByExternalIdMutationVariables>;
6439
- export declare const UntagClientDocument: Apollo.DocumentNode;
6440
- export type UntagClientMutationFn = Apollo.MutationFunction<UntagClientMutation, UntagClientMutationVariables>;
6441
- /**
6442
- * __useUntagClientMutation__
6443
- *
6444
- * To run a mutation, you first call `useUntagClientMutation` within a React component and pass it any options that fit your needs.
6445
- * When your component renders, `useUntagClientMutation` returns a tuple that includes:
6446
- * - A mutate function that you can call at any time to execute the mutation
6447
- * - An object with fields that represent the current status of the mutation's execution
6448
- *
6449
- * @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;
6450
- *
6451
- * @example
6452
- * const [untagClientMutation, { data, loading, error }] = useUntagClientMutation({
6453
- * variables: {
6454
- * input: // value for 'input'
6455
- * },
6456
- * });
6457
- */
6458
- export declare function useUntagClientMutation(baseOptions?: Apollo.MutationHookOptions<UntagClientMutation, UntagClientMutationVariables>): Apollo.MutationTuple<UntagClientMutation, Exact<{
6459
- input: ClientTagInput;
6460
- }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6461
- export type UntagClientMutationHookResult = ReturnType<typeof useUntagClientMutation>;
6462
- export type UntagClientMutationResult = Apollo.MutationResult<UntagClientMutation>;
6463
- export type UntagClientMutationOptions = Apollo.BaseMutationOptions<UntagClientMutation, UntagClientMutationVariables>;
6464
- export declare const UntagConvDocument: Apollo.DocumentNode;
6465
- export type UntagConvMutationFn = Apollo.MutationFunction<UntagConvMutation, UntagConvMutationVariables>;
6466
- /**
6467
- * __useUntagConvMutation__
6468
- *
6469
- * To run a mutation, you first call `useUntagConvMutation` within a React component and pass it any options that fit your needs.
6470
- * When your component renders, `useUntagConvMutation` returns a tuple that includes:
6471
- * - A mutate function that you can call at any time to execute the mutation
6472
- * - An object with fields that represent the current status of the mutation's execution
6473
- *
6474
- * @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;
6475
- *
6476
- * @example
6477
- * const [untagConvMutation, { data, loading, error }] = useUntagConvMutation({
6478
- * variables: {
6479
- * input: // value for 'input'
6480
- * },
6481
- * });
6482
- */
6483
- export declare function useUntagConvMutation(baseOptions?: Apollo.MutationHookOptions<UntagConvMutation, UntagConvMutationVariables>): Apollo.MutationTuple<UntagConvMutation, Exact<{
6484
- input: ConvTagInput;
6485
- }>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
6486
- export type UntagConvMutationHookResult = ReturnType<typeof useUntagConvMutation>;
6487
- export type UntagConvMutationResult = Apollo.MutationResult<UntagConvMutation>;
6488
- export type UntagConvMutationOptions = Apollo.BaseMutationOptions<UntagConvMutation, UntagConvMutationVariables>;
6489
6799
  export declare const ValidateBulkImportContactsDocument: Apollo.DocumentNode;
6490
6800
  /**
6491
6801
  * __useValidateBulkImportContactsQuery__
@@ -6527,88 +6837,6 @@ export declare function refetchValidateBulkImportContactsQuery(variables: Valida
6527
6837
  input: ValidateBulkImportContactsInput;
6528
6838
  }>;
6529
6839
  };
6530
- export declare const WabaMessageTemplateDetailsDocument: Apollo.DocumentNode;
6531
- /**
6532
- * __useWabaMessageTemplateDetailsQuery__
6533
- *
6534
- * To run a query within a React component, call `useWabaMessageTemplateDetailsQuery` and pass it any options that fit your needs.
6535
- * When your component renders, `useWabaMessageTemplateDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
6536
- * you can use to render your UI.
6537
- *
6538
- * @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;
6539
- *
6540
- * @example
6541
- * const { data, loading, error } = useWabaMessageTemplateDetailsQuery({
6542
- * variables: {
6543
- * input: // value for 'input'
6544
- * },
6545
- * });
6546
- */
6547
- export declare function useWabaMessageTemplateDetailsQuery(baseOptions: Apollo.QueryHookOptions<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables> & ({
6548
- variables: WabaMessageTemplateDetailsQueryVariables;
6549
- skip?: boolean;
6550
- } | {
6551
- skip: boolean;
6552
- })): Apollo.QueryResult<WabaMessageTemplateDetailsQuery, Exact<{
6553
- input: WabaMessageTemplateDetailsInput;
6554
- }>>;
6555
- export declare function useWabaMessageTemplateDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables>): Apollo.LazyQueryResultTuple<WabaMessageTemplateDetailsQuery, Exact<{
6556
- input: WabaMessageTemplateDetailsInput;
6557
- }>>;
6558
- export declare function useWabaMessageTemplateDetailsSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables>): Apollo.UseSuspenseQueryResult<WabaMessageTemplateDetailsQuery | undefined, Exact<{
6559
- input: WabaMessageTemplateDetailsInput;
6560
- }>>;
6561
- export type WabaMessageTemplateDetailsQueryHookResult = ReturnType<typeof useWabaMessageTemplateDetailsQuery>;
6562
- export type WabaMessageTemplateDetailsLazyQueryHookResult = ReturnType<typeof useWabaMessageTemplateDetailsLazyQuery>;
6563
- export type WabaMessageTemplateDetailsSuspenseQueryHookResult = ReturnType<typeof useWabaMessageTemplateDetailsSuspenseQuery>;
6564
- export type WabaMessageTemplateDetailsQueryResult = Apollo.QueryResult<WabaMessageTemplateDetailsQuery, WabaMessageTemplateDetailsQueryVariables>;
6565
- export declare function refetchWabaMessageTemplateDetailsQuery(variables: WabaMessageTemplateDetailsQueryVariables): {
6566
- query: Apollo.DocumentNode;
6567
- variables: Exact<{
6568
- input: WabaMessageTemplateDetailsInput;
6569
- }>;
6570
- };
6571
- export declare const WabaMessageTemplatesDocument: Apollo.DocumentNode;
6572
- /**
6573
- * __useWabaMessageTemplatesQuery__
6574
- *
6575
- * To run a query within a React component, call `useWabaMessageTemplatesQuery` and pass it any options that fit your needs.
6576
- * When your component renders, `useWabaMessageTemplatesQuery` returns an object from Apollo Client that contains loading, error, and data properties
6577
- * you can use to render your UI.
6578
- *
6579
- * @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;
6580
- *
6581
- * @example
6582
- * const { data, loading, error } = useWabaMessageTemplatesQuery({
6583
- * variables: {
6584
- * input: // value for 'input'
6585
- * },
6586
- * });
6587
- */
6588
- export declare function useWabaMessageTemplatesQuery(baseOptions: Apollo.QueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables> & ({
6589
- variables: WabaMessageTemplatesQueryVariables;
6590
- skip?: boolean;
6591
- } | {
6592
- skip: boolean;
6593
- })): Apollo.QueryResult<WabaMessageTemplatesQuery, Exact<{
6594
- input: WabaMessageTemplatesInput;
6595
- }>>;
6596
- export declare function useWabaMessageTemplatesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>): Apollo.LazyQueryResultTuple<WabaMessageTemplatesQuery, Exact<{
6597
- input: WabaMessageTemplatesInput;
6598
- }>>;
6599
- export declare function useWabaMessageTemplatesSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>): Apollo.UseSuspenseQueryResult<WabaMessageTemplatesQuery | undefined, Exact<{
6600
- input: WabaMessageTemplatesInput;
6601
- }>>;
6602
- export type WabaMessageTemplatesQueryHookResult = ReturnType<typeof useWabaMessageTemplatesQuery>;
6603
- export type WabaMessageTemplatesLazyQueryHookResult = ReturnType<typeof useWabaMessageTemplatesLazyQuery>;
6604
- export type WabaMessageTemplatesSuspenseQueryHookResult = ReturnType<typeof useWabaMessageTemplatesSuspenseQuery>;
6605
- export type WabaMessageTemplatesQueryResult = Apollo.QueryResult<WabaMessageTemplatesQuery, WabaMessageTemplatesQueryVariables>;
6606
- export declare function refetchWabaMessageTemplatesQuery(variables: WabaMessageTemplatesQueryVariables): {
6607
- query: Apollo.DocumentNode;
6608
- variables: Exact<{
6609
- input: WabaMessageTemplatesInput;
6610
- }>;
6611
- };
6612
6840
  export declare const AiDocument: Apollo.DocumentNode;
6613
6841
  /**
6614
6842
  * __useAiQuery__