Mutations
accountPreferenceUpsert
Creates or updates account-level preferences.
accountPreferenceUpsert(
input: AccountPreferenceUpsertInput!
): AccountPreferenceUpsertPayload
affiliatesClickCreate
No description
affiliatesClickCreate(
input: ClickCreateInput!
): ClickCreatePayload
agentNotificationPreferenceBulkDelete
Deletes agent notification preferences.
agentNotificationPreferenceBulkDelete(
input: AgentNotificationPreferenceBulkDeleteInput!
): AgentNotificationPreferenceBulkDeletePayload
agentNotificationPreferenceBulkUpsert
Creates or updates agent notification preferences.
agentNotificationPreferenceBulkUpsert(
input: AgentNotificationPreferenceBulkUpsertInput!
): AgentNotificationPreferenceBulkUpsertPayload
agentPreferenceDelete
Deletes agent preferences.
agentPreferenceDelete(
input: AgentPreferenceDeleteInput!
): AgentPreferenceDeletePayload
agentPreferenceUpsert
Creates or updates agent preferences.
agentPreferenceUpsert(
input: AgentPreferenceUpsertInput!
): AgentPreferenceUpsertPayload
agentResetLoginAttempts
Reset a teammate's 2FA login attempt counter to zero. Available to admins and owners for agents in their own account. Cannot be used on yourself.
agentResetLoginAttempts(
input: AgentResetLoginAttemptsInput!
): AgentResetLoginAttemptsPayload
agentResetPassword
agentResetPassword(
input: AgentResetPasswordInput!
): AgentResetPasswordPayload
agentSendAdminEmailNotification
agentSendAdminEmailNotification(
input: AgentSendAdminEmailNotificationInput!
): AgentSendAdminEmailNotificationPayload
aiConversationSuggestionUpsert
Starts or refreshes an AI suggestion for a conversation.
For example:
mutation SuggestionUpsert($conversationId: ID!, $suggestionType: AiConversationSuggestionType!) {
aiConversationSuggestionUpsert(input: {
conversationId: $conversationId,
suggestionType: $suggestionType
}) {
errors {
message
path
}
}
}
aiConversationSuggestionUpsert(
input: SuggestionUpsertInput!
): SuggestionUpsertPayload
asyncRpc
No description
asyncRpc(
input: AsyncRpcInput!
): AsyncRpcPayload
cancelDowngrade
cancelDowngrade(
input: CancelDowngradeInput!
): CancelDowngradePayload
cardSetupIntentCreate
cardSetupIntentCreate(
input: CardSetupIntentCreateInput!
): CardSetupIntentCreatePayload
cardSetupIntentSucceed
cardSetupIntentSucceed(
input: CardSetupIntentSucceedInput!
): CardSetupIntentSucceedPayload
channelDelete
Deletes an existing channel from the Inbox.
Example usage:
mutation($channelId: ID!) {
channelDelete(input: { channelId: $channelId }) {
deletedChannelId
errors {
path
message
}
}
}
channelDelete(
input: ChannelDeleteInput!
): ChannelDeletePayload
channelDisconnect
No description
channelDisconnect(
input: DisconnectMutationInput!
): DisconnectMutationPayload
channelEmailCreate
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
channelEmailUpdate
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
channelImport
No description
channelImport(
input: ImportMutationInput!
): ImportMutationPayload
checkAccessByMatrixIds
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
companyAddContacts
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
companyCreate
Creates a company.
For example:
mutation CompanyCreate(
$customFields: [CustomFieldInput!]
) {
companyCreate(
input: {
customFields: $customFields
}
) {
company {
id
}
errors {
message
path
}
}
}
companyCreate(
input: CompanyCreateInput!
): CompanyCreatePayload
companyDelete
Deletes a company.
For example:
mutation CompanyDelete($companyId: ID!) {
companyDelete(input: { companyId: $companyId }) {
deletedCompanyId
errors {
message
path
}
}
}
companyDelete(
input: CompanyDeleteInput!
): CompanyDeletePayload
companyMerge
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.
For example:
mutation CompanyMerge($companyId: ID!, $targetId: ID!) {
companyMerge(input: { companyId: $companyId, targetId: $targetId }) {
target {
id
}
errors {
message
path
}
}
}
companyMerge(
input: CompanyMergeInput!
): CompanyMergePayload
companyRemoveContacts
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
contactCreate
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
contactDelete
Deletes a contact permanently.
For example:
mutation ContactDelete($contactId: ID!) {
contactDelete(input: { contactId: $contactId }) {
deletedContactId
errors {
message
path
}
}
}
contactDelete(
input: ContactDeleteInput!
): ContactDeletePayload
contactMerge
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
contactResync
Updates a contact.
mutation ContactResync(
$contactId: ID!,
$integrationId: ID!
) {
contactResync(input: {
contactId: $contactId,
integrationId: $contactId
}) {
contact {
id
}
errors {
message
path
}
}
}
contactResync(
input: ContactResyncInput!
): ContactResyncPayload
contactUpdate
Updates a contact.
For example:
mutation ContactUpdate(
$contactId: ID!,
$contactType: ContactType!
) {
contactUpdate(input: {
contactId: $contactId,
contactType: $contactType
}) {
contact {
id
}
errors {
message
path
}
}
}
contactUpdate(
input: ContactUpdateInput!
): ContactUpdatePayload
conversationAddNote
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
conversationAssign
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
conversationBulkDelete
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
conversationChangeChannel
Move a conversation to another channel.
conversationChangeChannel(
input: ConversationChangeChannelInput!
): ConversationChangeChannelPayload
conversationChangeContact
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
conversationClose
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
conversationCreateEmail
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
conversationDelete
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
conversationDeleteNote
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
conversationEditNote
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
conversationFollow
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
conversationForward
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
conversationForwardV2
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
conversationLinkResource
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
conversationLog
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
conversationMerge
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
conversationMoveMessage
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
conversationOpen
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
conversationReply
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
conversationRestore
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
conversationSnooze
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
conversationSpam
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
conversationStar
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
conversationSubject
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
conversationTag
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
conversationToggleNoteReaction
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
conversationTrash
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
conversationUnassign
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
conversationUndoSend
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
conversationUnfollow
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
conversationUnread
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
conversationUnstar
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
conversationUntag
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
customFieldCategoryCreate
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
customFieldCategoryDelete
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
customFieldCategoryUpdate
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
customFieldCreate
Creates a custom field.
For example:
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
customFieldDelete
Deletes a custom field.
For example:
mutation CustomFieldDelete(
$customFieldId: ID!,
$deleteMode: DeleteMode
) {
customFieldDelete(input: {
customFieldId: $customFieldId,
deleteMode: $deleteMode
}) {
deletedCustomFieldId
errors {
message
path
}
}
}
customFieldDelete(
input: CustomFieldDeleteInput!
): CustomFieldDeletePayload
customFieldOptionDelete
Deletes a custom field option.
mutation CustomFieldOptionDelete($customFieldOptionId: ID!) {
customFieldOptionDelete(input: { customFieldOptionId: $customFieldOptionId }) {
errors {
path
message
}
}
}
customFieldOptionDelete(
input: CustomFieldOptionDeleteInput!
): CustomFieldOptionDeletePayload
customFieldRemove
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
customFieldRestore
No description
customFieldRestore(
input: customFieldRestoreInput!
): customFieldRestorePayload
customFieldUpdate
Updates a custom field.
For example:
mutation CustomFieldUpdate(
$customFieldId: ID!,
$categoryId: ID!,
$name: String!,
$icon: CustomFieldIcon,
$type: CustomFieldType!,
$options: [CustomFieldOptionInput]
) {
customFieldUpdate(input: {
customFieldId: $customFieldId,
categoryId: $categoryId,
name: $name,
icon: $icon,
type: $type,
options: $options
}) {
customField {
id
}
errors {
message
path
}
}
}
customFieldUpdate(
input: CustomFieldUpdateInput!
): CustomFieldUpdatePayload
customFieldValuesBulkUpdate
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
customFieldValuesUpdate
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
customerRatingSettingDelete
No description
customerRatingSettingDelete(
input: CustomerRatingSettingDeleteInput!
): CustomerRatingSettingDeletePayload
customerRatingSettingUpsert
No description
customerRatingSettingUpsert(
input: CustomerRatingSettingUpsertInput!
): CustomerRatingSettingUpsertPayload
draftDelete
Deletes a draft.
For example:
mutation(
$draftId: String!,
) {
draftRemove( input: {
draftId: $draftId,
}) {
deletedDraftId
success
}
}
draftDelete(
input: DraftDeleteInput!
): DraftDeletePayload
draftSave
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
draftUpsert
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
emailMarketingSubscriptionCreate
No description
emailMarketingSubscriptionCreate(
input: EmailMarketingSubscriptionCreateInput!
): EmailMarketingSubscriptionCreatePayload
emailMarketingSubscriptionDelete
No description
emailMarketingSubscriptionDelete(
input: EmailMarketingSubscriptionDeleteInput!
): EmailMarketingSubscriptionDeletePayload
enduserUpsert
No description
enduserUpsert(
input: CrmEnduserUpsertInput!
): CrmEnduserUpsertPayload
eventsShopifyCreate
eventsShopifyCreate(
input: EventsShopifyCreateInput!
): EventsShopifyCreatePayload
excludedDomainCreate
Creates an excluded domain.
mutation(
$domain: String!
) {
excludedDomainCreate(
input: {
domain: $domain
}
) {
excludedDomain {
id
domain
}
errors {
message
path
}
}
}
excludedDomainCreate(
input: ExcludedDomainCreateInput!
): ExcludedDomainCreatePayload
excludedDomainDelete
Deletes an excluded domain.
mutation ExcludedDomainDelete($excludedDomainId: ID!) {
excludedDomainDelete(input: { excludedDomainId: $excludedDomainId }) {
deletedExcludedDomainId
errors {
message
path
}
}
}
excludedDomainDelete(
input: ExcludedDomainDeleteInput!
): ExcludedDomainDeletePayload
excludedDomainUpdate
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
folderCreate
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
folderDelete
Deletes an Inbox folder.
mutation(
$folderId: ID!
) {
folderDelete(
input: {
folderId: $folderId
}
) {
deletedFolderId
errors {
path
message
}
}
}
folderDelete(
input: FolderDeleteInput!
): FolderDeletePayload
folderUpdate
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
import2Create
No description
import2Create(
input: Import2CreateInput!
): Import2CreatePayload
integrationDelete
Delete an integration.
Example:
mutation IntegrationDelete($integrationId: ID!) {
integrationDelete(input: { integrationId: $integrationId }) {
deletedIntegrationId
errors {
path
message
}
}
}
integrationDelete(
input: IntegrationDeleteInput!
): IntegrationDeletePayload
integrationDeleteByProvider
Delete an integrations by provider.
Example:
mutation IntegrationDeleteByProvider($provider: IntegrationProvider!) {
integrationDeleteByProvider(input: { provider: $provider }) {
deletedIntegrationIds
errors {
path
message
}
}
}
integrationDeleteByProvider(
input: IntegrationDeleteByProviderInput!
): IntegrationDeleteByProviderPayload
integrationJiraServerUpsert
Update or create a Jira Server integration.
integrationJiraServerUpsert(
input: IntegrationJiraServerCreateInput!
): IntegrationJiraServerCreatePayload
integrationProviderSettingsUpdate
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
integrationSettingsUpdate
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
kbArticleDelete
Deletes a Knowledge Base article.
For example:
mutation KbArticleDelete($articleId: ID!) {
kbArticleDelete(input: { articleId: $articleId }) {
deletedArticleId
errors {
message
path
}
}
}
kbArticleDelete(
input: KbArticleDeleteInput!
): KbArticleDeletePayload
kbSlugAvailability
Checks whether a Knowledge Base article slug is available.
For example:
mutation KbSlugAvailability($knowledgeBaseId: ID!, $value: ID!) {
kbSlugAvailability(input: { knowledgeBaseId: $knowledgeBaseId, value: $value }) {
available
errors {
message
path
}
}
}
kbSlugAvailability(
input: KbSlugAvailabilityInput!
): KbSlugAvailabilityPayload
kbSubdomainAvailability
Checks whether a Knowledge Base subdomain is available.
For example:
mutation KbSubdomainAvailability($value: ID!) {
kbSubdomainAvailability(input: { value: $value }) {
available
suggestion
errors {
message
path
}
}
}
kbSubdomainAvailability(
input: KbSubdomainAvailabilityInput!
): KbSubdomainAvailabilityPayload
login
Authenticates an agent and returns credentials or a two-factor authentication challenge.
For example:
mutation Login($subdomain: String!, $email: String!, $password: String!) {
login(input: { subdomain: $subdomain, email: $email, password: $password }) {
authState
otpChallenge
otpIdentifier
credentials {
token
expiresAt
}
user {
id
email
}
errors {
message
path
}
}
}
login(
input: LoginInput!
): LoginPayload
mobileNotificationPreferencesUpsert
No description
mobileNotificationPreferencesUpsert(
input: MobileNotificationPreferencesUpsertInput!
): MobileNotificationPreferencesUpsertPayload
pushTokenClearNotificationCount
pushTokenClearNotificationCount(
input: PushTokenClearNotificationCountInput!
): PushTokenClearNotificationCountPayload
pushTokenCreate
Creates a mobile push notification token for the current agent.
For example:
mutation PushTokenCreate($token: String!) {
pushTokenCreate(input: { token: $token }) {
pushToken {
id
}
errors {
message
path
}
}
}
pushTokenCreate(
input: PushTokenCreateInput!
): PushTokenCreatePayload
pushTokenDelete
pushTokenDelete(
input: PushTokenDeleteInput!
): PushTokenDeletePayload
roomDelete
Deletes a Live Chat room.
mutation RoomDelete($conversationId: ID!) {
roomDelete(input: { conversationId: $conversationId }) {
deletedConversationId
errors {
message
path
}
}
}
roomDelete(
input: DeleteRoomInput!
): DeleteRoomPayload
rpc
No description
rpc(
input: SyncRpcInput!
): SyncRpcPayload
ruleCreate
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
ruleDelete
Deletes a Rule.
mutation($ruleId: ID!) {
ruleDelete(input: { ruleId: $ruleId }) {
deletedRuleId
errors {
path
message
}
}
}
ruleDelete(
input: RuleDeleteInput!
): RuleDeletePayload
ruleUpdate
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
starredCannedReplyCreate
No description
starredCannedReplyCreate(
input: StarredCannedReplyCreateInput!
): StarredCannedReplyCreatePayload
starredCannedReplyDelete
No description
starredCannedReplyDelete(
input: StarredCannedReplyDeleteInput!
): StarredCannedReplyDeletePayload
tagBatchDelete
Deletes an Inbox tag.
mutation(
$filter: TagFilter,
$tagIds: [ID!]
) {
tagBatchDelete(
input: {
filter: $filter,
tagIds: $tagIds,
}
) {
jobId
errors {
path
message
}
}
}
tagBatchDelete(
input: TagBatchDeleteInput!
): TagBatchDeletePayload
tagCreate
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
tagDelete
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
tagMerge
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
tagUpdate
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
teamCreate
Creates a team and optionally assigns agents to it.
For example:
mutation TeamsCreate($name: String!, $description: String, $agentIds: [ID!]) {
teamsCreate(input: { name: $name, description: $description, agentIds: $agentIds }) {
team {
id
name
}
errors {
message
path
}
}
}
teamCreate(
input: teamsCreateInput!
): teamsCreatePayload
teamDestroy
Deletes a team.
For example:
mutation TeamsDestroy($teamId: ID!) {
teamsDestroy(input: { teamId: $teamId }) {
team {
id
name
}
errors {
message
path
}
}
}
teamDestroy(
input: teamsDestroyInput!
): teamsDestroyPayload
teamUpdate
Updates a team and optionally replaces its assigned agents.
For example:
mutation TeamsUpdate($teamId: ID!, $name: String, $description: String, $agentIds: [String!]) {
teamsUpdate(input: { teamId: $teamId, name: $name, description: $description, agentIds: $agentIds }) {
team {
id
name
}
errors {
message
path
}
}
}
teamUpdate(
input: teamsUpdateInput!
): teamsUpdatePayload
updatePresence
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
uploadPayloadGenerate
followed by a field, in your POST request.
uploadPayloadGenerate(
input: UploadPayloadGenerateInput!
): UploadPayloadGeneratePayload
walletTransactionCreate
No description
walletTransactionCreate(
input: WalletTransactionCreateInput!
): WalletTransactionCreatePayload
walletUpdate
No description
walletUpdate(
input: WalletUpdateInput!
): WalletUpdatePayload
webhookCreate
Creates a webhook.
Example usage:
mutation WebhookCreate($event: WebhookEvent!, $url: String!) {
webhookCreate(input: { event: $event, url: $url }) {
webhook {
id
event
url
state
}
errors {
path
message
}
}
}
Variables:
{
"event": "TICKET_STARTED",
"url": "https://example.com/webhooks/groove"
}
webhookCreate(
input: WebhookCreateInput!
): WebhookCreatePayload
webhookDelete
Deletes a webhook.
Example usage:
mutation WebhookDelete($webhookId: ID!) {
webhookDelete(input: { webhookId: $webhookId }) {
deletedWebhookId
errors {
path
message
}
}
}
Variables:
{
"webhookId": "wh_0000000000"
}
webhookDelete(
input: WebhookDeleteInput!
): WebhookDeletePayload
webhookReactivate
Reactivates a webhook.
Example usage:
mutation WebhookReactivate($webhookId: ID!) {
webhookReactivate(input: { webhookId: $webhookId }) {
webhook {
id
event
url
state
}
errors {
path
message
}
}
}
Variables:
{
"webhookId": "wh_0000000000"
}
webhookReactivate(
input: WebhookReactivateInput!
): WebhookReactivatePayload
webhookTest
Sends a test payload to a webhook.
Example usage:
mutation WebhookTest($webhookId: ID!) {
webhookTest(input: { webhookId: $webhookId }) {
webhook {
id
event
url
state
}
statusCode
success
errors {
path
message
}
}
}
Variables:
{
"webhookId": "wh_0000000000"
}
webhookTest(
input: WebhookTestInput!
): WebhookTestPayload
webhookUpdate
Updates a webhook.
Example usage:
mutation WebhookUpdate($webhookId: ID!, $event: WebhookEvent, $url: String) {
webhookUpdate(input: { webhookId: $webhookId, event: $event, url: $url }) {
webhook {
id
event
url
state
}
errors {
path
message
}
}
}
Variables:
{
"webhookId": "wh_0000000000",
"event": "TICKET_STARTED",
"url": "https://example.com/webhooks/groove"
}
webhookUpdate(
input: WebhookUpdateInput!
): WebhookUpdatePayload
widgetHelplyProvision
Provisions a Helply account and widgets from Groove data using silent provision mode (no user invitation).
widgetHelplyProvision(
input: WidgetHelplyProvisionInput!
): WidgetHelplyProvisionPayload