Mutations

affiliatesClickCreate#

Type: ClickCreatePayload

No description

affiliatesClickCreate(
input: ClickCreateInput!
): ClickCreatePayload

Input fields#

agentNotificationPreferenceBulkDelete#

Type: AgentNotificationPreferenceBulkDeletePayload

Deletes agent notification preferences.

agentNotificationPreferenceBulkDelete(
input: AgentNotificationPreferenceBulkDeleteInput!
): AgentNotificationPreferenceBulkDeletePayload

Input fields#

agentNotificationPreferenceBulkUpsert#

Type: AgentNotificationPreferenceBulkUpsertPayload

Creates or updates agent notification preferences.

agentNotificationPreferenceBulkUpsert(
input: AgentNotificationPreferenceBulkUpsertInput!
): AgentNotificationPreferenceBulkUpsertPayload

Input fields#

agentPreferenceDelete#

Type: AgentPreferenceDeletePayload

Deletes agent preferences.

agentPreferenceDelete(
input: AgentPreferenceDeleteInput!
): AgentPreferenceDeletePayload

Input fields#

agentPreferenceUpsert#

Type: AgentPreferenceUpsertPayload

Creates or updates agent preferences.

agentPreferenceUpsert(
input: AgentPreferenceUpsertInput!
): AgentPreferenceUpsertPayload

Input fields#

agentResetLoginAttempts#

Type: AgentResetLoginAttemptsPayload

agentResetLoginAttempts(
input: AgentResetLoginAttemptsInput!
): AgentResetLoginAttemptsPayload

Input fields#

agentResetPassword#

Type: AgentResetPasswordPayload

agentResetPassword(
input: AgentResetPasswordInput!
): AgentResetPasswordPayload

Input fields#

agentSendAdminEmailNotification#

Type: AgentSendAdminEmailNotificationPayload

agentSendAdminEmailNotification(
input: AgentSendAdminEmailNotificationInput!
): AgentSendAdminEmailNotificationPayload

Input fields#

aiConversationSuggestionUpsert#

Type: SuggestionUpsertPayload

No description

aiConversationSuggestionUpsert(
input: SuggestionUpsertInput!
): SuggestionUpsertPayload

Input fields#

asyncRpc#

Type: AsyncRpcPayload

No description

asyncRpc(
input: AsyncRpcInput!
): AsyncRpcPayload

Input fields#

cancelDowngrade#

Type: CancelDowngradePayload

cancelDowngrade(
input: CancelDowngradeInput!
): CancelDowngradePayload

Input fields#

cardSetupIntentCreate#

Type: CardSetupIntentCreatePayload

cardSetupIntentCreate(
input: CardSetupIntentCreateInput!
): CardSetupIntentCreatePayload

Input fields#

cardSetupIntentSucceed#

Type: CardSetupIntentSucceedPayload

cardSetupIntentSucceed(
input: CardSetupIntentSucceedInput!
): CardSetupIntentSucceedPayload

Input fields#

channelDelete#

Type: ChannelDeletePayload

Deletes an existing channel from the Inbox.

Example usage:

mutation($channelId: ID!) {
channelDelete(input: { channelId: $channelId }) {
deletedChannelId
errors {
path
message
}
}
}
channelDelete(
input: ChannelDeleteInput!
): ChannelDeletePayload

Input fields#

channelDisconnect#

Type: DisconnectMutationPayload

No description

channelDisconnect(
input: DisconnectMutationInput!
): DisconnectMutationPayload

Input fields#

channelEmailCreate#

Type: EmailChannelCreatePayload

Creates a new email channel in the inbox.

Example usage:

mutation(
$type: ChannelType!
$email: String
$name: String!
$senderName: String
$color: String!
$permittedAgentIds: [ID]
$permittedTeamIds: [ID]
$signature: String
$incomingEmailServer: ImapServerInput
$outgoingEmailServer: SmtpServerInput
$position: Int
$emailTemplates: [EmailTemplateInput]
$aiDraftsChannelIds: [ID]
$aiDraftsKnowledgeBaseIds: [ID]
$autoBccAddress: String
$useAgentName: Boolean
$threadingType: ThreadingType
) {
channelEmailCreate(
input: {
type: $type
email: $email
name: $name
senderName: $senderName
color: $color
permittedAgentIds: $permittedAgentIds
permittedTeamIds: $permittedTeamIds
signature: $signature
incomingEmailServer: $incomingEmailServer
outgoingEmailServer: $outgoingEmailServer
position: $position
emailTemplates: $emailTemplates
aiDraftsChannelIds: $aiDraftsChannelIds
aiDraftsKnowledgeBaseIds: $aiDraftsKnowledgeBaseIds
autoBccAddress: $autoBccAddress
useAgentName: $useAgentName
threadingType: $threadingType
}
) {
channel {
id
color
name
}
errors {
path
message
}
}
}
channelEmailCreate(
input: EmailChannelCreateInput!
): EmailChannelCreatePayload

Input fields#

channelEmailUpdate#

Type: EmailChannelUpdatePayload

Update an existing Inbox email channel.

Example usage:

mutation(
$channelId: ID!
$type: ChannelType!
$email: String
$name: String!
$senderName: String
$color: String!
$permittedAgentIds: [ID]
$permittedTeamIds: [ID]
$signature: String
$incomingEmailServer: ImapServerInput
$outgoingEmailServer: SmtpServerInput
$position: Int
$emailTemplates: [EmailTemplateInput]
$aiDraftsChannelIds: [ID]
$aiDraftsKnowledgeBaseIds: [ID]
$autoBccAddress: String
$useAgentName: Boolean
$threadingType: ThreadingType
) {
channelEmailUpdate(
input: {
channelId: $channelId
type: $type
email: $email
name: $name
senderName: $senderName
color: $color
permittedAgentIds: $permittedAgentIds
permittedTeamIds: $permittedTeamIds
signature: $signature
incomingEmailServer: $incomingEmailServer
outgoingEmailServer: $outgoingEmailServer
position: $position
emailTemplates: $emailTemplates
aiDraftsChannelIds: $aiDraftsChannelIds
aiDraftsKnowledgeBaseIds: $aiDraftsKnowledgeBaseIds
autoBccAddress: $autoBccAddress
useAgentName: $useAgentName
threadingType: $threadingType
}
) {
channel {
id
color
name
}
errors {
path
message
}
}
}
channelEmailUpdate(
input: EmailChannelUpdateInput!
): EmailChannelUpdatePayload

Input fields#

channelImport#

Type: ImportMutationPayload

No description

channelImport(
input: ImportMutationInput!
): ImportMutationPayload

Input fields#

checkAccessByMatrixIds#

Type: CheckAccessByMatrixIdsPayload

Returns the provided list of Matrix room IDs with a flag indicating the ability of the current use to access each of them.

mutation CheckAccessByMatrixIds($matrixRoomIds: [ID]) {
checkAccessByMatrixIds(input: { matrixRoomIds: $matrixRoomIds }) {
rooms {
id
number
hasAccess
}
}
}
checkAccessByMatrixIds(
input: CheckAccessByMatrixIdsInput!
): CheckAccessByMatrixIdsPayload

Input fields#

companyAddContacts#

Type: CompanyAddContactsPayload

Adds contacts to a company.

For example:

mutation CompanyAddContacts($companyId: ID!, $contactIds: [ID!]!) {
companyAddContacts(
input: { companyId: $companyId, contactIds: $contactIds }
) {
company {
contacts {
nodes {
id
}
}
}
errors {
message
path
}
}
}
companyAddContacts(
input: CompanyAddContactsInput!
): CompanyAddContactsPayload

Input fields#

companyCreate#

Type: CompanyCreatePayload

Creates a company.

For example:

mutation CompanyCreate($customFields: [CustomFieldInput!]) {
companyCreate(input: { customFields: $customFields }) {
company {
id
}
errors {
message
path
}
}
}
companyCreate(
input: CompanyCreateInput!
): CompanyCreatePayload

Input fields#

companyDelete#

Type: CompanyDeletePayload

Deletes a company.

For example:

mutation CompanyDelete($companyId: ID!) {
companyDelete(input: { companyId: $companyId }) {
deletedCompanyId
errors {
message
path
}
}
}
companyDelete(
input: CompanyDeleteInput!
): CompanyDeletePayload

Input fields#

companyMerge#

Type: CompanyMergePayload

Merges one company (the source) into another company (the target). The target company is preserved, and the source company is deleted.

The fields in keepFieldIds from the source company will be preserved in the merge, and will be merged into the destination company.

mutation CompanyMerge($companyId: ID!, $targetId: ID!) {
companyMerge(input: { companyId: $companyId, targetId: $targetId }) {
target {
id
}
errors {
message
path
}
}
}
companyMerge(
input: CompanyMergeInput!
): CompanyMergePayload

Input fields#

companyRemoveContacts#

Type: CompanyRemoveContactsPayload

Remove contacts from a company.

For example:

mutation CompanyRemoveContacts($companyId: ID!, $contactIds: [ID!]!) {
companyRemoveContacts(
input: { companyId: $companyId, contactIds: $contactIds }
) {
company {
contacts {
nodes {
id
}
}
}
errors {
message
path
}
}
}
companyRemoveContacts(
input: CompanyRemoveContactsInput!
): CompanyRemoveContactsPayload

Input fields#

contactCreate#

Type: ContactCreatePayload

Creates a contact.

For example:

mutation ContactCreate(
$contactType: ContactType!
$customFields: [CustomFieldInput!]
) {
contactCreate(
input: { contactType: $contactType, customFields: $customFields }
) {
contact {
id
}
errors {
message
path
}
}
}
contactCreate(
input: ContactCreateInput!
): ContactCreatePayload

Input fields#

contactDelete#

Type: ContactDeletePayload

Deletes a contact permanently.

mutation ContactDelete($contactId: ID!) {
contactDelete(input: { contactId: $contactId }) {
deletedContactId
errors {
message
path
}
}
}
contactDelete(
input: ContactDeleteInput!
): ContactDeletePayload

Input fields#

contactMerge#

Type: ContactMergePayload

Merges one contact (the source) into another contact (the target). The target contact is preserved, and the source contact is deleted.

The fields in keepFieldIds from the source contact will be preserved in the merge, and will be merged into the destination contact.

mutation ContactMerge($sourceId: ID!, $targetId: ID!, $keepFieldIds: [ID!]) {
contactMerge(
input: {
sourceId: $sourceId
targetId: $targetId
keepFieldIds: $keepFieldIds
}
) {
target {
id
}
errors {
message
path
}
}
}
contactMerge(
input: ContactMergeInput!
): ContactMergePayload

Input fields#

contactResync#

Type: ContactResyncPayload

Updates a contact.

mutation ContactResync($contactId: ID!, $integrationId: ID!) {
contactResync(input: { contactId: $contactId, integrationId: $contactId }) {
contact {
id
}
errors {
message
path
}
}
}
contactResync(
input: ContactResyncInput!
): ContactResyncPayload

Input fields#

contactUpdate#

Type: ContactUpdatePayload

Updates a contact.

mutation ContactUpdate($contactId: ID!, $contactType: ContactType) {
contactUpdate(input: { contactId: $contactId, contactType: $contactType }) {
contact {
id
}
errors {
message
path
}
}
}
contactUpdate(
input: ContactUpdateInput!
): ContactUpdatePayload

Input fields#

conversationAddNote#

Type: conversationAddNotePayload

Create a note in a conversation.

mutation(
$conversationId: ID!
$body: String!
$draftId: String
$state: ConversationState
$snoozedUntil: DateTime
$attachments: [EmailAttachmentInput]
$skipNotifications: Boolean
) {
conversationAddNote(
input: {
conversationId: $conversationId
body: $body
draftId: $draftId
state: $state
snoozedUntil: $snoozedUntil
attachments: $attachments
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
}
message {
id
}
deletedDraftId
errors {
path
message
}
}
}
conversationAddNote(
input: conversationAddNoteInput!
): conversationAddNotePayload

Input fields#

conversationAssign#

Type: ConversationAssignPayload

Assigns a conversation to an agent, a team, or both.

For example:

mutation(
$agentId: ID
$conversationId: ID!
$teamId: ID
$skipNotifications: Boolean
) {
conversationAssign(
input: {
agentId: $agentId
conversationId: $conversationId
teamId: $teamId
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
... on Conversation {
id
assigned {
at
agent {
id
name
}
team {
id
name
}
}
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To unassign a conversation see conversationUnassign.

conversationAssign(
input: ConversationAssignInput!
): ConversationAssignPayload

Input fields#

conversationBulkDelete#

Type: ConversationBulkDeletePayload

Deletes any number of conversations. Conversations can be either soft deleted or hard deleted.

mutation conversationBulkDelete(
$conversationIds: ["cnv_1234567"],
$deleteMode: HARD
) {
conversationBulkDelete(
input: {
conversationIds: $conversationIds,
deleteMode: $deleteMode
}
) {
jid
}
}
conversationBulkDelete(
input: ConversationBulkDeleteInput!
): ConversationBulkDeletePayload

Input fields#

conversationChangeChannel#

Type: ConversationChangeChannelPayload

Move a conversation to another channel.

conversationChangeChannel(
input: ConversationChangeChannelInput!
): ConversationChangeChannelPayload

Input fields#

conversationChangeContact#

Type: ConversationChangeContactPayload

Change the contact associated with a conversation.

For example:

mutation($conversationId: ID!, $contactId: ID!) {
conversationChangeContact(
input: { conversationId: $conversationId, contactId: $contactId }
) {
conversation {
id
}
diffs {
query
delta
}
errors {
message
path
}
}
}
conversationChangeContact(
input: ConversationChangeContactInput!
): ConversationChangeContactPayload

Input fields#

conversationClose#

Type: ConversationClosePayload

Sets a conversation's state to CLOSED.

For example:

mutation($conversationId: ID!) {
conversationClose(input: { conversationId: $conversationId }) {
changesetId
conversation {
... on Conversation {
id
state
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationClose(
input: ConversationCloseInput!
): ConversationClosePayload

Input fields#

conversationCreateEmail#

Type: ConversationCreateEmailPayload

Creates a new email conversation.

For example:

mutation(
$assigned: AssignmentInput,
$channelId: ID!,
$message: EmailMessageInput!,
$state: ConversationState,
$cannedReplyId: ID,
$draftId: String,
$snoozeUntil: DateTime,
$tagIds: [ID],
$skipNotifications: Boolean
) {
conversationCreateEmail(
input: {
assigned: $assigned,
channelId: $channelId,
message: $message,
state: $state,
cannedReplyId: $cannedReplyId,
draftId: $draftId,
snoozeUntil: $snoozeUntil,
tagIds: $tagIds,
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
state
subject
}
errors {
path
message
}
}
})
conversationCreateEmail(
input: ConversationCreateEmailInput!
): ConversationCreateEmailPayload

Input fields#

conversationDelete#

Type: ConversationDeletePayload

Deletes up to 25 conversations. Conversations can be either soft deleted or hard deleted.

To trash (soft delete) conversations:

mutation(
$conversationIds: ["cnv_1234567"],
$deleteMode: SOFT,
) {
conversationDelete(
input: {
conversationIds: $conversationIds,
deleteMode: $deleteMode
}
) {
deletedConversationIds
diffs {
query
delta
}
errors {
path
message
}
}
}

To permanently delete conversations:

mutation(
$conversationIds: ["cnv_1234567"],
$deleteMode: HARD,
) {
conversationDelete(
input: {
conversationId: $conversationId,
deleteMode: $deleteMode
}
) {
deletedConversationIds
errors {
path
message
}
}
}
conversationDelete(
input: ConversationDeleteInput!
): ConversationDeletePayload

Input fields#

conversationDeleteNote#

Type: conversationDeleteNotePayload

Delete note for comment

mutation($messageId: ID!, $skipNotifications: Boolean) {
conversationDeleteNote(
input: { messageId: $messageId, skipNotifications: $skipNotifications }
) {
changesetId
deletedMessageId
conversation {
id
}
errors {
path
message
}
}
}
conversationDeleteNote(
input: conversationDeleteNoteInput!
): conversationDeleteNotePayload

Input fields#

conversationEditNote#

Type: conversationEditNotePayload

Edit a note in a conversation.

mutation(
$messageId: ID!
$body: String!
$attachments: [EmailAttachmentInput]
$skipNotifications: Boolean
) {
conversationEditNote(
input: {
messageId: $messageId
body: $body
attachments: $attachments
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
}
message {
id
}
errors {
path
message
}
}
}
conversationEditNote(
input: conversationEditNoteInput!
): conversationEditNotePayload

Input fields#

conversationFollow#

Type: ConversationFollowPayload

Adds one or more agents as followers to a conversation.

For example:

mutation(
$conversationId: ID!,
$followerIds: [ID!]!
) {
conversationFollow(
input: {
conversationId: $conversationId,
followerIds: $followerIds
}
) {
changesetId
conversation {
... on Conversation {
id
followers {
edges {
node {
id
email
}
}
}
}
}
diffs {
query
delta
}
errors {
path
message
}
}
})

To unfollow a conversation see conversationUnfollow.

conversationFollow(
input: ConversationFollowInput!
): ConversationFollowPayload

Input fields#

conversationForward#

Type: ConversationForwardPayload

Forwards a conversation.

mutation(
$conversationId: ID!
$body: String!
$to: Email!
$cc: [Email]
$bcc: [Email]
$subject: String
$attachments: [EmailAttachmentInput]
$cannedReplyId: ID
$draftId: String
$state: ConversationState
$snoozeUntil: DateTime
$agentId: ID
$teamId: ID
$channelId: ID
$skipNotifications: Boolean
) {
conversationForward(
input: {
conversationId: $conversationId
body: $body
to: $to
cc: $cc
bcc: $bcc
subject: $subject
attachments: $attachments
cannedReplyId: $cannedReplyId
draftId: $draftId
state: $state
snoozeUntil: $snoozeUntil
agentId: $agentId
teamId: $teamId
channelId: $channelId
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
}
message {
id
}
deletedDraftId
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationForward(
input: ConversationForwardInput!
): ConversationForwardPayload

Input fields#

conversationForwardV2#

Type: ConversationForwardV2Payload

Forwards a conversation.

mutation(
$conversationId: ID!
$body: String!
$to: [Email!]!
$cc: [Email]
$bcc: [Email]
$subject: String
$attachments: [EmailAttachmentInput]
$cannedReplyId: ID
$draftId: String
$state: ConversationState
$snoozeUntil: DateTime
$tagIdsToAdd: [ID]
$tagIdsToRemove: [ID]
$removeAllTags: Boolean
$agentId: ID
$teamId: ID
$channelId: ID
$skipNotifications: Boolean
) {
conversationForwardV2(
input: {
conversationId: $conversationId
body: $body
to: $to
cc: $cc
bcc: $bcc
subject: $subject
attachments: $attachments
cannedReplyId: $cannedReplyId
draftId: $draftId
state: $state
snoozeUntil: $snoozeUntil
tagIdsToAdd: $tagIdsToAdd
tagIdsToRemove: $tagIdsToRemove
removeAllTags: $removeAllTags
agentId: $agentId
teamId: $teamId
channelId: $channelId
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
}
message {
id
}
deletedDraftId
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationForwardV2(
input: ConversationForwardV2Input!
): ConversationForwardV2Payload

Input fields#

conversationLinkResource#

Type: conversationLinkResourcePayload

Link an integration resource to the conversation

mutation(
$conversationId: ID!
$externalId: String!
$provider: IntegrationProvider!
$removed: Boolean
$title: String!
$url: String!
) {
conversationLinkResource(
input: {
conversationId: $conversationId
externalId: $externalId
provider: $provider
removed: $removed
title: $title
url: $url
}
) {
changesetId
conversation {
id
}
errors {
path
message
}
}
}
conversationLinkResource(
input: conversationLinkResourceInput!
): conversationLinkResourcePayload

Input fields#

conversationLog#

Type: ConversationLogPayload

Creates a new conversation starting with a note.

mutation ConversationLog(
$assigned: AssignmentInput
$channelId: ID!
$message: NoteMessageInput!
$state: ConversationState
$cannedReplyId: ID
$draftId: String
$snoozeUntil: DateTime
$skipNotifications: Boolean
) {
conversationLog(
input: {
assigned: $assigned
channelId: $channelId
message: $message
state: $state
cannedReplyId: $cannedReplyId
draftId: $draftId
snoozeUntil: $snoozeUntil
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
subject
contact {
id
email
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationLog(
input: ConversationLogInput!
): ConversationLogPayload

Input fields#

conversationMerge#

Type: ConversationMergePayload

Merges one conversation (the source) into another conversation (the target). The target conversation is preserved, and the source conversation is deleted.

For example:

conversationMerge(
input: ConversationMergeInput!
): ConversationMergePayload

Input fields#

conversationMoveMessage#

Type: ConversationMoveMessagePayload

Moves a message out of a conversation to create a new conversation.

mutation($input: { messageId: ID! }) {
conversationMoveMessage(input: $input) {
conversation {
id
}
}
})
conversationMoveMessage(
input: ConversationMoveMessageInput!
): ConversationMoveMessagePayload

Input fields#

conversationOpen#

Type: ConversationOpenPayload

Sets a conversation's state to OPENED.

For example:

mutation($conversationId: ID!) {
conversationOpen(input: { conversationId: $conversationId }) {
changesetId
conversation {
... on Conversation {
id
state
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationOpen(
input: ConversationOpenInput!
): ConversationOpenPayload

Input fields#

conversationReply#

Type: ConversationReplyPayload

Replies to a conversation.

mutation(
$conversationId: ID!
$body: String!
$to: Email!
$cc: [Email]
$bcc: [Email]
$subject: String
$attachments: [EmailAttachmentInput]
$cannedReplyId: ID
$draftId: String
$state: ConversationState
$snoozedUntil: DateTime
$tagIdsToAdd: [ID]
$tagIdsToRemove: [ID]
$removeAllTags: Boolean
$agentId: ID
$teamId: ID
$channelId: ID
$skipNotifications: Boolean
) {
conversationReply(
input: {
conversationId: $conversationId
body: $body
to: $to
cc: $cc
bcc: $bcc
subject: $subject
attachments: $attachments
cannedReplyId: $cannedReplyId
draftId: $draftId
state: $state
snoozedUntil: $snoozedUntil
tagIdsToAdd: $tagIdsToAdd
tagIdsToRemove: $tagIdsToRemove
removeAllTags: $removeAllTags
agentId: $agentId
teamId: $teamId
channelId: $channelId
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
}
message {
id
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationReply(
input: ConversationReplyInput!
): ConversationReplyPayload

Input fields#

conversationRestore#

Type: conversationRestorePayload

Restores up to 25 soft-deleted conversations.

mutation(
$conversationIds: ["cnv_1234567"],
$newState: OPENED
) {
conversationDelete(
input: {
conversationIds: $conversationIds,
newState: $newState
}
) {
conversations {
nodes {
id
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationRestore(
input: conversationRestoreInput!
): conversationRestorePayload

Input fields#

conversationSnooze#

Type: ConversationSnoozePayload

Snoozes a conversation. Conversations can be either snoozed until a specific date or indefinitely.

For example:

mutation($conversationId: ID!, $until: DateTime!) {
conversationSnooze(
input: { conversationId: $conversationId, until: $until }
) {
changesetId
conversation {
... on Conversation {
id
state
snoozed {
by {
id
}
until
}
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To unsnooze and reopen a conversation use conversationOpen.

To unsnooze a conversation while keeping it closed use conversationClose.

conversationSnooze(
input: ConversationSnoozeInput!
): ConversationSnoozePayload

Input fields#

conversationSpam#

Type: ConversationSpamPayload

Marks the conversation as spam.

For example:

mutation($conversationId: ID!) {
conversationSpam(input: { conversationId: $conversationId }) {
changesetId
conversation {
... on Conversation {
id
state
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationSpam(
input: ConversationSpamInput!
): ConversationSpamPayload

Input fields#

conversationStar#

Type: ConversationStarPayload

Stars a conversation.

For example:

mutation($conversationId: ID!) {
conversationStar(input: { conversationId: $conversationId }) {
changesetId
conversation {
... on Conversation {
id
starred
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To unstar a conversation see conversationUnstar,

conversationStar(
input: ConversationStarInput!
): ConversationStarPayload

Input fields#

conversationSubject#

Type: ConversationSubjectPayload

Updates the conversation subject.

For example:

mutation($conversationId: ID!, $subject: String!) {
conversationSubject(
input: { conversationId: $conversationId, subject: $subject }
) {
changesetId
conversation {
... on Conversation {
id
subject
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationSubject(
input: ConversationSubjectInput!
): ConversationSubjectPayload

Input fields#

conversationTag#

Type: ConversationTagPayload

Add one or more tags to a Conversation.

For example:

mutation($conversationId: ID!, $tagIds: [ID!]!) {
conversationTag(input: { conversationId: $conversationId, tagIds: $tagIds }) {
changesetId
conversation {
... on Conversation {
id
tags {
edges {
node {
id
name
}
}
}
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To untag a conversation see conversationUntag.

conversationTag(
input: ConversationTagInput!
): ConversationTagPayload

Input fields#

conversationToggleNoteReaction#

Type: conversationToggleNoteReactionPayload

Toggle note reaction for comment

mutation($messageId: ID!, $reaction: String!, $skipNotifications: Boolean) {
conversationToggleNoteReaction(
input: {
messageId: $messageId
reaction: $reaction
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
id
}
message {
id
}
errors {
path
message
}
}
}
conversationToggleNoteReaction(
input: conversationToggleNoteReactionInput!
): conversationToggleNoteReactionPayload

Input fields#

conversationTrash#

Type: ConversationTrashPayload

Sets a conversation's state to DELETED.

For example:

mutation($conversationId: ID!) {
conversationTrash(input: { conversationId: $conversationId }) {
changesetId
conversation {
... on Conversation {
id
state
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationTrash(
input: ConversationTrashInput!
): ConversationTrashPayload

Input fields#

conversationUnassign#

Type: ConversationUnassignPayload

Unassigns a conversation from an agent, a team, or both.

For example:

mutation(
$agent: Boolean
$conversationId: ID!
$team: Boolean
$skipNotifications: Boolean
) {
conversationUnassign(
input: {
agent: $agent
conversationId: $conversationId
team: $team
skipNotifications: $skipNotifications
}
) {
changesetId
conversation {
... on Conversation {
id
assigned {
at
agent {
id
name
}
team {
id
name
}
}
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To assign a conversation see conversationAssign.

conversationUnassign(
input: ConversationUnassignInput!
): ConversationUnassignPayload

Input fields#

conversationUndoSend#

Type: conversationUndoSendPayload

Undo the sending of a new conversation, reply or forward.

mutation($conversationId: ID!, $changesetId: ID!) {
conversationUndoSend(
input: { conversationId: $conversationId, changesetId: $changesetId }
) {
changesetId
errors {
path
message
}
}
}
conversationUndoSend(
input: conversationUndoSendInput!
): conversationUndoSendPayload

Input fields#

conversationUnfollow#

Type: ConversationUnfollowPayload

Removes one or more agents as followers from a conversation.

For example:

mutation($conversationId: ID!, $followerIds: [ID!]!) {
conversationUnfollow(
input: { conversationId: $conversationId, followerIds: $followerIds }
) {
changesetId
conversation {
... on Conversation {
id
followers {
edges {
node {
id
email
}
}
}
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To follow a conversation see conversationFollow.

conversationUnfollow(
input: ConversationUnfollowInput!
): ConversationUnfollowPayload

Input fields#

conversationUnread#

Type: ConversationUnreadPayload

Sets a conversation's state to UNREAD.

For example:

mutation($conversationId: ID!) {
conversationUnread(input: { conversationId: $conversationId }) {
changesetId
conversation {
... on Conversation {
id
state
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}
conversationUnread(
input: ConversationUnreadInput!
): ConversationUnreadPayload

Input fields#

conversationUnstar#

Type: ConversationUnstarPayload

Unstars a conversation.

For example:

mutation($conversationId: ID!) {
conversationUnstar(input: { conversationId: $conversationId }) {
changesetId
conversation {
... on Conversation {
id
starred
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To star a conversation see conversationStar,

conversationUnstar(
input: ConversationUnstarInput!
): ConversationUnstarPayload

Input fields#

conversationUntag#

Type: ConversationUntagPayload

Removes one or more tags from a conversation.

For example:

mutation($conversationId: ID!, $tagIds: [ID!]!) {
conversationUntag(
input: { conversationId: $conversationId, tagIds: $tagIds }
) {
changesetId
conversation {
... on Conversation {
id
tags {
edges {
node {
id
name
}
}
}
}
}
diffs {
query
delta
}
errors {
path
message
}
}
}

To tag a conversation see conversationTag.

conversationUntag(
input: ConversationUntagInput!
): ConversationUntagPayload

Input fields#

customFieldCategoryCreate#

Type: CustomFieldCategoryCreatePayload

Creates a custom field category.

mutation CustomFieldCategoryCreate(
$name: String!
$type: CustomFieldCategoryType!
$key: String!
) {
customFieldCategoryCreate(input: { name: $name, type: $type, key: $key }) {
errors {
message
path
}
category {
id
}
}
}
customFieldCategoryCreate(
input: CustomFieldCategoryCreateInput!
): CustomFieldCategoryCreatePayload

Input fields#

customFieldCategoryDelete#

Type: CustomFieldCategoryDeletePayload

Deletes a custom field category.

mutation CustomFieldCategoryDelete($categoryId: ID!, $newCategoryId: ID) {
customFieldCategoryDelete(
input: { categoryId: $categoryId, newCategoryId: $newCategoryId }
) {
deletedCategoryId
errors {
message
path
}
}
}
customFieldCategoryDelete(
input: CustomFieldCategoryDeleteInput!
): CustomFieldCategoryDeletePayload

Input fields#

customFieldCategoryUpdate#

Type: CustomFieldCategoryUpdatePayload

Updates a custom field category.

mutation CustomFieldCategoryUpdate($categoryId: ID!, $name: String!) {
customFieldCategoryUpdate(input: { categoryId: $categoryId, name: $name }) {
errors {
message
path
}
category {
id
}
}
}
customFieldCategoryUpdate(
input: CustomFieldCategoryUpdateInput!
): CustomFieldCategoryUpdatePayload

Input fields#

customFieldCreate#

Type: CustomFieldCreatePayload

Creates a custom field.

mutation CustomFieldCreate(
$categoryId: ID!
$key: String!
$name: String!
$icon: CustomFieldIcon
$description: String
$type: CustomFieldType!
$placeholder: String
$isArray: Boolean!
$options: [CustomFieldOptionInput]
) {
customFieldCreate(
input: {
categoryId: $categoryId
key: $key
name: $name
icon: $icon
description: $description
type: $type
placeholder: $placeholder
isArray: $isArray
options: $options
}
) {
customField {
id
}
errors {
message
path
}
}
}
customFieldCreate(
input: CustomFieldCreateInput!
): CustomFieldCreatePayload

Input fields#

customFieldDelete#

Type: CustomFieldDeletePayload

Deletes a custom field.

mutation CustomFieldDelete($customFieldId: ID!, $deleteMode: Boolean) {
customFieldDelete(
input: { customFieldId: $customFieldId, deleteMode: $deleteMode }
) {
errors {
message
path
}
}
}
customFieldDelete(
input: CustomFieldDeleteInput!
): CustomFieldDeletePayload

Input fields#

customFieldOptionDelete#

Type: CustomFieldOptionDeletePayload

Deletes a custom field option.

mutation CustomFieldOptionDelete($customFieldOptionId: ID!) {
customFieldOptionDelete(
input: { customFieldOptionId: $customFieldOptionId }
) {
errors {
path
message
}
}
}
customFieldOptionDelete(
input: CustomFieldOptionDeleteInput!
): CustomFieldOptionDeletePayload

Input fields#

customFieldRemove#

Type: CustomFieldRemovePayload

Removes a custom field from a contact or company.

mutation CustomFieldRemove($customFieldId: ID!, $itemId: ID!) {
customFieldRemove(input: { customFieldId: $customFieldId, itemId: $itemId }) {
errors {
message
path
}
}
}
customFieldRemove(
input: CustomFieldRemoveInput!
): CustomFieldRemovePayload

Input fields#

customFieldRestore#

Type: customFieldRestorePayload

No description

customFieldRestore(
input: customFieldRestoreInput!
): customFieldRestorePayload

Input fields#

customFieldUpdate#

Type: CustomFieldUpdatePayload

Updates a custom field.

mutation CustomFieldUpdate(
$customFieldId: ID!
$categoryId: ID!
$name: String
$icon: CustomFieldIcon
$options: [CustomFieldOptionInput]
) {
customFieldUpdate(
input: {
customFieldId: $customFieldId
categoryId: $categoryId
name: $name
icon: $icon
options: $options
}
) {
errors {
message
path
}
}
}
customFieldUpdate(
input: CustomFieldUpdateInput!
): CustomFieldUpdatePayload

Input fields#

customFieldValuesBulkUpdate#

Type: CustomFieldValuesBulkUpdatePayload

Updates multiple contact or company custom fields in one go.

This is important if, for example, you want to constantly synchronize your contacts with an external data source.

Changes will be proccessed asynchronously in the background.

mutation CustomFieldValuesBulkUpdate(
$items: [SubjectWithCustomFieldsInput!]!
$sync: Boolean!
) {
customFieldValuesBulkUpdate(input: { items: $items, sync: $sync }) {
jid
}
}
customFieldValuesBulkUpdate(
input: CustomFieldValuesBulkUpdateInput!
): CustomFieldValuesBulkUpdatePayload

Input fields#

customFieldValuesUpdate#

Type: CustomFieldValuesUpdatePayload

Creates, updates, or deletes custom field values for a contact or company.

mutation CustomFieldValuesUpdate(
$subjectId: ID!
$customFieldList: [CustomFieldListInput]
) {
customFieldValuesUpdate(
input: { subjectId: $subjectId, customFieldList: $values }
) {
subject {
id
}
}
}

Example request, with payload in the payload.json file:

curl 'https://api.groovehq.com/v2/graphql' -H 'Accept: application/json' -H 'Content-Type: application/json' -H 'Authorization: Bearer TOKEN' -d payload.json

Example payload.json file:

{
"query":"
mutation UpdateCustomFieldValue(
$input: CustomFieldValuesUpdateInput!
) {
customFieldValuesUpdate(input: $input) {
subject {
id
}
errors {
message
path
type
}
}
}
",
"_method":"POST",
"variables": {
"input": {
"subjectId":"co_0000000000",
"customFieldList":[
{
"customFieldIdOrKey":"cf_0000000000",
"value":"My new value"
}
]
},
}
}
customFieldValuesUpdate(
input: CustomFieldValuesUpdateInput!
): CustomFieldValuesUpdatePayload

Input fields#

customerRatingSettingDelete#

Type: CustomerRatingSettingDeletePayload

No description

customerRatingSettingDelete(
input: CustomerRatingSettingDeleteInput!
): CustomerRatingSettingDeletePayload

Input fields#

customerRatingSettingUpsert#

Type: CustomerRatingSettingUpsertPayload

No description

customerRatingSettingUpsert(
input: CustomerRatingSettingUpsertInput!
): CustomerRatingSettingUpsertPayload

Input fields#

draftDelete#

Type: DraftDeletePayload

Deletes a draft.

For example:

mutation($draftId: String!) {
draftRemove(input: { draftId: $draftId }) {
deletedDraftId
success
}
}
draftDelete(
input: DraftDeleteInput!
): DraftDeletePayload

Input fields#

draftSave#

Type: DraftSavePayload

DEPRECATED Please use DraftUpsert.

Creates or updates a draft.

For example:

mutation(
$draftId: ID!,
$conversationId: ID!,
$version: Int!,
$draftType String!,
$payload: String!,
) {
draftSave( input: {
draftId: $draftId,
conversationId: $conversationId,
version: $version,
draftType: $payload,
payload: $payload,
}) {
draftId
version
}
}
draftSave(
input: DraftSaveInput!
): DraftSavePayload

Input fields#

draftUpsert#

Type: DraftUpsertPayload

Upserts a draft

For example:

mutation(
$draftId: String!,
$conversationId: ID!,
$version: Int!,
$draftType DraftType!,
$payload: JSON!,
$metadata: JSON!
) {
draftSave( input: {
draftId: $draftId,
conversationId: $conversationId,
version: $version,
draftType: $payload,
payload: $payload,
metadata: $metadata
}) {
draft {
id
}
version
}
}
draftUpsert(
input: DraftUpsertInput!
): DraftUpsertPayload

Input fields#

emailMarketingSubscriptionCreate#

Type: EmailMarketingSubscriptionCreatePayload

No description

emailMarketingSubscriptionCreate(
input: EmailMarketingSubscriptionCreateInput!
): EmailMarketingSubscriptionCreatePayload

Input fields#

emailMarketingSubscriptionDelete#

Type: EmailMarketingSubscriptionDeletePayload

No description

emailMarketingSubscriptionDelete(
input: EmailMarketingSubscriptionDeleteInput!
): EmailMarketingSubscriptionDeletePayload

Input fields#

enduserUpsert#

Type: CrmEnduserUpsertPayload

No description

enduserUpsert(
input: CrmEnduserUpsertInput!
): CrmEnduserUpsertPayload

Input fields#

eventsShopifyCreate#

Type: EventsShopifyCreatePayload

eventsShopifyCreate(
input: EventsShopifyCreateInput!
): EventsShopifyCreatePayload

Input fields#

excludedDomainCreate#

Type: ExcludedDomainCreatePayload

Creates an excluded domain.

mutation($domain: String!) {
excludedDomainCreate(input: { domain: $domain }) {
excludedDomain {
id
domain
}
errors {
message
path
}
}
}
excludedDomainCreate(
input: ExcludedDomainCreateInput!
): ExcludedDomainCreatePayload

Input fields#

excludedDomainDelete#

Type: ExcludedDomainDeletePayload

Deletes an excluded domain.

mutation ExcludedDomainDelete($excludedDomainId: ID!) {
excludedDomainDelete(input: { excludedDomainId: $excludedDomainId }) {
deletedExcludedDomainId
errors {
message
path
}
}
}
excludedDomainDelete(
input: ExcludedDomainDeleteInput!
): ExcludedDomainDeletePayload

Input fields#

excludedDomainUpdate#

Type: ExcludedDomainUpdatePayload

Updates an excluded domain.

mutation($excludedDomainId: ID!, $domain: String!) {
excludedDomainCreate(
input: { excludedDomainId: $excludedDomainId, domain: $domain }
) {
excludedDomain {
id
domain
}
errors {
message
path
}
}
}
excludedDomainUpdate(
input: ExcludedDomainUpdateInput!
): ExcludedDomainUpdatePayload

Input fields#

folderCreate#

Type: FolderCreatePayload

Creates an Inbox folder.

mutation(
$name: String!
$description: String
$matchType: FolderMatchTypes!
$state: FolderState!
$position: Int
$displayCountWhenInactive: Boolean
$hideIfZeroConversations: Boolean
$permittedAgentIds: [ID!]
$permittedTeamIds: [ID!]
$channelIds: [ID!]
$conditions: [ConditionInput!]!
) {
folderCreate(
input: {
name: $name
description: $description
matchType: $matchType
state: $state
position: $position
displayCountWhenInactive: $displayCountWhenInactive
hideIfZeroConversations: $hideIfZeroConversations
permittedAgentIds: $permittedAgentIds
permittedTeamIds: $permittedTeamIds
channelIds: $channelIds
conditions: $conditions
}
) {
folder {
id
name
}
errors {
path
message
}
}
}
folderCreate(
input: FolderCreateInput!
): FolderCreatePayload

Input fields#

folderDelete#

Type: FolderDeletePayload

Deletes an Inbox folder.

mutation($folderId: ID!) {
folderDelete(input: { folderId: $folderId }) {
deletedFolderId
errors {
path
message
}
}
}
folderDelete(
input: FolderDeleteInput!
): FolderDeletePayload

Input fields#

folderUpdate#

Type: FolderUpdatePayload

Updates an Inbox folder.

mutation(
$folderId: ID!
$name: String!
$description: String
$matchType: FolderMatchTypes!
$state: FolderState!
$position: Int
$displayCountWhenInactive: Boolean
$hideIfZeroConversations: Boolean
$permittedAgentIds: [ID!]
$permittedTeamIds: [ID!]
$channelIds: [ID!]
$conditions: [ConditionInput!]!
) {
folderUpdate(
input: {
folderId: $folderId
name: $name
description: $description
matchType: $matchType
state: $state
position: $position
displayCountWhenInactive: $displayCountWhenInactive
hideIfZeroConversations: $hideIfZeroConversations
permittedAgentIds: $permittedAgentIds
permittedTeamIds: $permittedTeamIds
channelIds: $channelIds
conditions: $conditions
}
) {
folder {
id
name
}
errors {
path
message
}
}
}
folderUpdate(
input: FolderUpdateInput!
): FolderUpdatePayload

Input fields#

import2Create#

Type: Import2CreatePayload

No description

import2Create(
input: Import2CreateInput!
): Import2CreatePayload

Input fields#

integrationDelete#

Type: IntegrationDeletePayload

Delete an integration.

Example:

mutation IntegrationDelete($integrationId: ID!) {
integrationDelete(input: { integrationId: $integrationId }) {
deletedIntegrationId
errors {
path
message
}
}
}
integrationDelete(
input: IntegrationDeleteInput!
): IntegrationDeletePayload

Input fields#

integrationDeleteByProvider#

Type: IntegrationDeleteByProviderPayload

Delete an integrations by provider.

Example:

mutation IntegrationDeleteByProvider($provider: IntegrationProvider!) {
integrationDeleteByProvider(input: { provider: $provider }) {
deletedIntegrationIds
errors {
path
message
}
}
}
integrationDeleteByProvider(
input: IntegrationDeleteByProviderInput!
): IntegrationDeleteByProviderPayload

Input fields#

integrationJiraServerUpsert#

Type: IntegrationJiraServerCreatePayload

Update or create a Jira Server integration.

integrationJiraServerUpsert(
input: IntegrationJiraServerCreateInput!
): IntegrationJiraServerCreatePayload

Input fields#

integrationProviderSettingsUpdate#

Type: IntegrationProviderSettingsUpdatePayload

Update settings for all integrations for a specific provider.

For example:

mutation IntegrationSettingsUpdate(
$provider: IntegrationProvider!
$settings: JSON!
) {
integrationSettingsUpdate(
input: { provider: $provider, settings: $settings }
) {
integrations {
nodes {
... on Integration {
provider
settings {
settings
}
}
}
}
settings {
settings
}
}
}
integrationProviderSettingsUpdate(
input: IntegrationProviderSettingsUpdateInput!
): IntegrationProviderSettingsUpdatePayload

Input fields#

integrationSettingsUpdate#

Type: IntegrationSettingsUpdatePayload

Update settings for an integration.

For example:

mutation IntegrationSettingsUpdate($integrationId: ID!, $settings: JSON!) {
integrationSettingsUpdate(
input: { integrationId: $integrationId, settings: $settings }
) {
integration {
... on Integration {
provider
settings {
id
settings
}
}
}
}
}
integrationSettingsUpdate(
input: IntegrationSettingsUpdateInput!
): IntegrationSettingsUpdatePayload

Input fields#

kbArticleDelete#

Type: KbArticleDeletePayload

No description

kbArticleDelete(
input: KbArticleDeleteInput!
): KbArticleDeletePayload

Input fields#

kbSlugAvailability#

Type: KbSlugAvailabilityPayload

No description

kbSlugAvailability(
input: KbSlugAvailabilityInput!
): KbSlugAvailabilityPayload

Input fields#

kbSubdomainAvailability#

Type: KbSubdomainAvailabilityPayload

No description

kbSubdomainAvailability(
input: KbSubdomainAvailabilityInput!
): KbSubdomainAvailabilityPayload

Input fields#

login#

Type: LoginPayload

No description

login(
input: LoginInput!
): LoginPayload

Input fields#

mobileNotificationPreferencesUpsert#

Type: MobileNotificationPreferencesUpsertPayload

No description

mobileNotificationPreferencesUpsert(
input: MobileNotificationPreferencesUpsertInput!
): MobileNotificationPreferencesUpsertPayload

Input fields#

pushTokenClearNotificationCount#

Type: PushTokenClearNotificationCountPayload

pushTokenClearNotificationCount(
input: PushTokenClearNotificationCountInput!
): PushTokenClearNotificationCountPayload

Input fields#

pushTokenCreate#

Type: PushTokenCreatePayload

No description

pushTokenCreate(
input: PushTokenCreateInput!
): PushTokenCreatePayload

Input fields#

pushTokenDelete#

Type: PushTokenDeletePayload

pushTokenDelete(
input: PushTokenDeleteInput!
): PushTokenDeletePayload

Input fields#

roomDelete#

Type: DeleteRoomPayload

Deletes a Live Chat room.

mutation RoomDelete($conversationId: ID!) {
roomDelete(input: { conversationId: $conversationId }) {
deletedConversationId
errors {
message
path
}
}
}
roomDelete(
input: DeleteRoomInput!
): DeleteRoomPayload

Input fields#

rpc#

Type: SyncRpcPayload

No description

rpc(
input: SyncRpcInput!
): SyncRpcPayload

Input fields#

ruleCreate#

Type: RuleCreatePayload

Creates a Rule.

mutation(
$name: String!
$description: String
$matchType: RuleMatchTypes!
$state: RuleState!
$position: Int
$conditions: [RuleConditionInput!]!
$triggers: [TriggerInput!]!
$actions: [ActionInput!]!
$scheduleType: ScheduleType!
$stopUpcoming: Boolean!
) {
ruleCreate(
input: {
name: $name
description: $description
matchType: $matchType
state: $state
position: $position
conditions: $conditions
triggers: $triggers
actions: $actions
scheduleType: $scheduleType
stopUpcoming: $stopUpcoming
}
) {
rule {
id
name
}
errors {
path
message
}
}
}
ruleCreate(
input: RuleCreateInput!
): RuleCreatePayload

Input fields#

ruleDelete#

Type: RuleDeletePayload

Deletes a Rule.

mutation($ruleId: ID!) {
ruleDelete(input: { ruleId: $ruleId }) {
deletedRuleId
errors {
path
message
}
}
}
ruleDelete(
input: RuleDeleteInput!
): RuleDeletePayload

Input fields#

ruleUpdate#

Type: RuleUpdatePayload

Updates a Rule.

mutation(
$ruleId: ID!
$name: String!
$description: String
$matchType: RuleMatchTypes!
$state: RuleState!
$position: Int
$conditions: [RuleConditionInput!]!
$triggers: [TriggerInput!]!
$actions: [ActionInput!]!
$scheduleType: ScheduleType
$scheduleSettings: FeatureTemplateRuleScheduleSettingsInput
$stopUpcoming: Boolean!
) {
ruleUpdate(
input: {
ruleId: $ruleId
name: $name
description: $description
matchType: $matchType
state: $state
position: $position
conditions: $conditions
triggers: $triggers
actions: $actions
scheduleType: $scheduleType
scheduleSettings: $scheduleSettings
stopUpcoming: $stopUpcoming
}
) {
rule {
id
name
}
errors {
path
message
}
}
}
ruleUpdate(
input: RuleUpdateInput!
): RuleUpdatePayload

Input fields#

starredCannedReplyCreate#

Type: StarredCannedReplyCreatePayload

No description

starredCannedReplyCreate(
input: StarredCannedReplyCreateInput!
): StarredCannedReplyCreatePayload

Input fields#

starredCannedReplyDelete#

Type: StarredCannedReplyDeletePayload

No description

starredCannedReplyDelete(
input: StarredCannedReplyDeleteInput!
): StarredCannedReplyDeletePayload

Input fields#

tagBatchDelete#

Type: TagBatchDeletePayload

Deletes an Inbox tag.

mutation($filter: TagFilter, $tagIds: [ID!]) {
tagBatchDelete(input: { filter: $filter, tagIds: $tagIds }) {
jobId
errors {
path
message
}
}
}
tagBatchDelete(
input: TagBatchDeleteInput!
): TagBatchDeletePayload

Input fields#

tagCreate#

Type: TagCreatePayload

Creates an Inbox tag.

mutation($color: String, $name: String!) {
tagCreate(input: { color: $color, name: $name }) {
tag {
id
color
name
}
errors {
path
message
}
}
}

To apply an existing tag to a conversation see conversationTag.

tagCreate(
input: TagCreateInput!
): TagCreatePayload

Input fields#

tagDelete#

Type: TagDeletePayload

Deletes an Inbox tag.

mutation($tagId: ID!) {
tagDelete(input: { tagId: $tagId }) {
deletedTagId
errors {
path
message
}
}
}

To remove an existing tag from a conversation see conversationUntag.

tagDelete(
input: TagDeleteInput!
): TagDeletePayload

Input fields#

tagMerge#

Type: TagMergePayload

Merges one or more tags into a parent tag.

mutation($parentTagId: ID!, $filter: TagFilter, $tagIds: [ID!]) {
tagMerge(
input: { parentTagId: $parentTagId, filter: $filter, tagIds: $tagIds }
) {
jobId
errors {
path
message
}
}
}
tagMerge(
input: TagMergeInput!
): TagMergePayload

Input fields#

tagUpdate#

Type: TagUpdatePayload

Updates an Inbox tag.

mutation($color: String, $name: String, $tagId: ID!) {
tagUpdate(input: { color: $color, name: $name, tagId: $tagId }) {
tag {
id
color
name
}
errors {
path
message
}
}
}

To change tags applied to a conversation see the conversationTag or conversationUntag mutations.

tagUpdate(
input: TagUpdateInput!
): TagUpdatePayload

Input fields#

teamCreate#

Type: teamsCreatePayload

No description

teamCreate(
input: teamsCreateInput!
): teamsCreatePayload

Input fields#

teamDestroy#

Type: teamsDestroyPayload

No description

teamDestroy(
input: teamsDestroyInput!
): teamsDestroyPayload

Input fields#

teamUpdate#

Type: teamsUpdatePayload

No description

teamUpdate(
input: teamsUpdateInput!
): teamsUpdatePayload

Input fields#

updatePresence#

Type: UpdatePresencePayload

Returns the provided list of Matrix room IDs with a flag indicating the ability of the current use to access each of them.

mutation UpdatePresence($presenceStatus: PresenceStatusTypeEnum!) {
updatePresence(input: { presenceStatus: $presenceStatus }) {
presenceStatus
lastActiveAt
updatedAt
accessibleWidgetIds
}
}
updatePresence(
input: UpdatePresenceInput!
): UpdatePresencePayload

Input fields#

uploadPayloadGenerate#

Type: UploadPayloadGeneratePayload

When uploading a new file to s3, you must include all of the payload fields in order, followed by a field, in your POST request.

uploadPayloadGenerate(
input: UploadPayloadGenerateInput!
): UploadPayloadGeneratePayload

Input fields#

walletTransactionCreate#

Type: WalletTransactionCreatePayload

No description

walletTransactionCreate(
input: WalletTransactionCreateInput!
): WalletTransactionCreatePayload

Input fields#

walletUpdate#

Type: WalletUpdatePayload

No description

walletUpdate(
input: WalletUpdateInput!
): WalletUpdatePayload

Input fields#

Edit this page

On this page