Interfaces

BaseInterface

No description

interface BaseInterface {
}

Channel

A channel is a source of incoming conversations. It dictates how messages in those conversations are sent and received.

For example, an EmailChannel is a channel where messages are sent as email. To fetch all of them:

query Channels {
  channels {
    nodes {
      ... on Channel {
        __typename
        id
        name
        conversationCount
      }
    }
  }
}

By default channels are sorted by their user-defined row-order, called their position. To sort by name instead:

query Channels {
  channels( orderBy: { field: NAME, direction: ASC } ) {
    nodes {
      ... on EmailChannel {
        id
      }
    }
  }
}

To find which agents have permission to view this channel:

query Channels {
  channels {
    nodes {
      id
      name
      permittedAgents {
        totalCount
        nodes {
          id
        }
      }
    }
  }
}

Only find channels where the user is granted access to view it:

query Channels {
  channels(filter: { scope: CURRENT_USER }) {
    nodes {
      id
      name
      permittedAgents {
        totalCount
        nodes {
          id
        }
      }
    }
  }
}

Find all channels the user is allowed to view. Admin users can always view all channels:

query Channels {
  channels(filter: { scope: ALL }) {
    nodes {
      id
      name
      permittedAgents {
        totalCount
        nodes {
          id
        }
      }
    }
  }
}

interface Channel {
  color: String!
  conversationCount(
  state: [ConversationState!]
): Int!
  createdAt: DateTime!
  customFields(
  after: String
  before: String
  first: Int
  last: Int
): CustomFieldConnection!
  errors: [ChannelErrorTypeUnion!]!
  folders(
  after: String
  before: String
  first: Int
  last: Int
  filter: FolderFilter
  orderBy: FolderOrder
): FolderConnection
  id: ID!
  name: String!
  permittedAgents(
  after: String
  before: String
  first: Int
  last: Int
  agentIds: [ID!]
): AgentConnection!
  pinnedSearches(
  after: String
  before: String
  first: Int
  last: Int
  filter: PinnedSearchFilter
  orderBy: PinnedSearchOrder
): PinnedSearchConnection
  restriction: Restriction!
  senderName: String
  state: ChannelState!
  tags(
  after: String
  before: String
  first: Int
  last: Int
  filter: TagFilter
  orderBy: TagOrder
): TagConnection
  type: ChannelType!
  updatedAt: DateTime!
}

CompaniesField

A list of companies filtered by input.

interface CompaniesField {
  companies(
  after: String
  before: String
  first: Int
  last: Int
  filter: CompanyFilter
  orderBy: CompanyOrder
): CompanyConnection
}

ContactsField

A list of contacts filtered by input.

interface ContactsField {
  contacts(
  after: String
  before: String
  first: Int
  last: Int
  filter: ContactFilter
  orderBy: ContactOrder
): ContactConnection
}

Conversation

A Groove conversation is a thread of messages (for example emails, chats, or notes) and associated actions or events (for example 'opened', 'snoozed', and 'assigned').

To fetch Messages/Ratings/StateChanges/etc. on a conversation, query the Events connection (on the QueryRoot) with the conversation ID.

To fetch all possible fields:

query Conversation {
  node(id: "cnv_12345678") {
    
        __typename
        ... on Conversation {
          assigned {
            at
            agent {
              id
              name
            }
            team {
              id
              name
            }
          }
          counts {
            attachments
            interactions
            messages
            notes
            stateChanges
          }
          createdAt
          contact {
            id
            email
          }
          deletedAt
          drafts {
            nodes {
              id
            }
          }
          followers {
            nodes {
              id
              email
            }
          }
          id
          number
          snoozed {
            by { id }
            until
          }
          starred
          state
          stateUpdatedAt
          summaryMessage {
            id
            bodyPlainText
          }
          subject
          systemUpdatedAt
          tags {
            nodes {
              id
              name
            }
          }
          updatedAt
          
        ... on FacebookConversation {
          facebookId
        }
      
          
        ... on TwitterConversation {
          twitterId
        }
      
          
        ... on WidgetConversation {
          browser
          referrer
          pageTitle
          pageUrl
          platform
          referrer
        }
      
        }
      
  }
}

To search conversations matching a specific keyword:

query Conversations {
  conversations(filter: { keywords: "rad" }) {
    edges {
      node {
        ... on Conversation {
          id
          number
          searchSummary {
            author {
              __typename
              ... on Agent {
                email
                role
              }
              ... on Contact {
                email
              }
            }
            body
            forwarded
            note
          }
        }
      }
    }
  }
}

interface Conversation {
  assigned: Assignment
  channel: Channel!
  contact: Contact
  counts: ConversationCounts!
  createdAt: DateTime!
  customFieldValues(
  after: String
  before: String
  first: Int
  last: Int
  filter: CustomFieldValuesFilter
): CustomFieldValueConnection
  deletedAt: DateTime
  drafts(
  after: String
  before: String
  first: Int
  last: Int
): DraftConnection
  followers(
  after: String
  before: String
  first: Int
  last: Int
  filter: AgentFilter
  orderBy: AgentOrder
): AgentConnection
  id: ID!
  lastUnansweredUserMessageAt: DateTime!
  mentions: [Mention!]!
  number: Int!
  searchSummary: SearchSummary
  snoozed: Snooze
  starred: Boolean!
  state: ConversationState!
  stateUpdatedAt: DateTime
  subject: String
  summaryMessage: SummaryMessage
  systemUpdatedAt: DateTime!
  tags(
  after: String
  before: String
  first: Int
  last: Int
  filter: TagFilter
  orderBy: TagOrder
): TagConnection
  updatedAt: DateTime!
}

CustomFieldValuesField

A list of custom fields filtered by input.

interface CustomFieldValuesField {
  customFieldValues(
  after: String
  before: String
  first: Int
  last: Int
  filter: CustomFieldValuesFilter
): CustomFieldValueConnection
}

Delayable

A message with delayed deliveries.

interface Delayable {
  deliverBy: DateTime
}

Draft

An object with timestamp fields for when it was created and last updated.

interface Draft {
  agent: Agent!
  assignment: Assignment
  contextId: ID
  conversation: Conversation!
  conversationId: ID!
  createdAt: DateTime!
  draftId: String
  draftType: DraftType
  id: ID!
  lastSyncedAt: DateTime!
  metadata: JSON!
  payload: JSON
  updatedAt: DateTime!
  version: Int!
}

EmailInterface

No description

interface EmailInterface {
  aiDraftsChannels: [EmailChannel!]
  aiDraftsKnowledgeBases: [KnowledgeBase!]
  aiQualityRating: String
  autoBccAddress: String
  color: String!
  email: String
  emailTemplates: [EmailTemplate!]!
  forwardEmailAddress: String!
  fromName: String!
  incomingEmailServer: IncomingServerTypeUnion
  outgoingEmailServer: OutgoingServerTypeUnion
  position: Int!
  provider: String!
  signature: String
  threadingType: ThreadingType!
  useAgentName: Boolean
}

Emailable

A message that is sent via email.

interface Emailable {
  bcc(
  after: String
  before: String
  first: Int
  last: Int
): RecipientConnection
  cc(
  after: String
  before: String
  first: Int
  last: Int
): RecipientConnection
  to(
  after: String
  before: String
  first: Int
  last: Int
): RecipientConnection!
}

ErrorType

Represents errors that occurred during channel integration operations.

interface ErrorType {
  createdAt: DateTime!
  message: String!
  type: String!
  updatedAt: DateTime!
}

Integration

An object with timestamp fields for when it was created and last updated.

interface Integration {
  createdAt: DateTime!
  id: ID!
  legacyId: String!
  provider: IntegrationProvider!
  settings: IntegrationSettings!
  uid: String
  updatedAt: DateTime!
}

Message

An individual message, for example an incoming email, an email reply, or a note.

interface Message {
  attachments(
  after: String
  before: String
  first: Int
  last: Int
): AttachmentConnection
  author: Author
  body: String
  bodyPlainText: String
  cannedReply: CannedReply
  channel: Channel!
  createdAt: DateTime!
  editedAt: DateTime
  fromMerge: Boolean
  fromMove: Boolean
  id: ID!
  isNote: Boolean!
  rule: Rule
  sourceConversation: Conversation
  summary: SummaryMessage!
  updatedAt: DateTime!
}

Node

An object with an ID.

interface Node {
  id: ID!
}

Previewable

A preview is a list of integers representing the number of lines and the respective lengths of multi-line content, for example messages, merges, and ratings. It can be used to build a visual approximation of the content of the change while the full change is being fetched.

An object implements previewable if preview lines can be derived from its content.

interface Previewable {
  preview: [Int!]
}

Publishable

An object that can be published, for example Knowledge Base categories or articles.

For example:

    ... on Publishable {
      author {
        id
        email
      }
      description
      featured
      meta {
        description
        robots
      }
      openGraph {
        description
        imageUrl
        title
      }
      pageTitle
      position
      publishedAt
      slug
      state
      title
      updater {
        id
        email
      }
    }
  

interface Publishable {
  author: Agent
  description: String
  featured: Boolean!
  meta: Meta
  openGraph: OpenGraph
  pageTitle: String
  position: Int!
  publishedAt: DateTime
  slug: String
  state: PublishState!
  title: String
  updater: Agent
}

Server

The interface for different server types.

interface Server {
  createdAt: DateTime!
  encryption: EncryptionType
  host: String!
  id: ID!
  port: Int!
  protocol: ProtocolType!
  updatedAt: DateTime!
  username: String!
  verified: Boolean!
}

Timestamped

An object with timestamp fields for when it was created and last updated.

interface Timestamped {
  createdAt: DateTime!
  updatedAt: DateTime!
}

Utilizationabled

An object with utilization fields for when it was last used and how many times it has been used.

interface Utilizationabled {
  countUsed: Int!
  lastUsedAt: DateTime
}