GraphQL API

mutation AcceptInvitation($id: ID!) {
  acceptInvitation(id: $id)
}

mutation AssociateGitTokenWithGitEntity($input: GitTokenAssociationInput!) {
  associateGitTokenWithGitEntity(input: $input) {
    id
    name
    value
    expiresAt
    flags
    status
    scopes
    createdAt
  }
}

mutation CancelTask($id: ID!) {
  cancelTask(id: $id)
}

query CheckGitToken($value: String!, $gitType: GitType!, $name: String) {
  checkGitToken(value: $value, gitType: $gitType, name: $name) {
    valid
    statusCode
    error
    expiresAt
    publicRepositoryCount
    privateRepositoryCount
  }
}

mutation ClearFindingTriage($repositoryId: ID!, $matchKey: String!) {
  clearFindingTriage(repositoryId: $repositoryId, matchKey: $matchKey)
}

query CommitScans($list: List) {
  commitScans(list: $list) {
    total
    items {
      id
      scanResultId
      commitHash
      createdAt
      updatedAt
    }
  }
}

mutation ConfirmEmptyOrder($id: ID!) {
  confirmEmptyOrder(id: $id)
}

mutation CreateEmptyOrder {
  createEmptyOrder {
    id
  }
}

mutation CreateGitEntity($input: CreateGitEntityInput!) {
  createGitEntity(input: $input) {
    __typename
    ... on Organization {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
    ... on GitUser {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
  }
}

mutation CreateGitToken($input: CreateGitTokenInput!) {
  createGitToken(input: $input) {
    id
    name
    value
    expiresAt
    flags
    status
    scopes
    createdAt
  }
}

mutation CreateInvoiceDownloadUrl($invoiceId: ID!) {
  createInvoiceDownloadUrl(invoiceId: $invoiceId) {
    url
    filename
    tenant
    contentType
  }
}

mutation CreateNetwork($input: CreateNetworkInput!) {
  createNetwork(input: $input) {
    id
    name
    network
    networkType
    tenant
    securityScore
    createdAt
    updatedAt
  }
}

mutation CreateNotificationScope($input: CreateNotificationScopeInput!) {
  createNotificationScope(input: $input) {
    id
    channelIds
    channelType
    scopes
    isActive
    status
    headers {
      name
      value
    }
    template
  }
}

mutation CreateRepository($input: CreateRepositoryInput!) {
  createRepository(input: $input) {
    id
    gitEntityId
    repositoryName
    private
    securityScore
    programmingLanguage
    repositorySize
    numberOfBranches
  }
}

mutation CreateScanSchedule($input: CreateScanScheduleInput!) {
  createScanSchedule(input: $input) {
    id
    action
    repositoryId
    gitEntityId
    branch
    dockerScanToolId
    frequency
    hourUtc
  }
}

mutation CreateServiceAccount($input: CreateServiceAccountInput!) {
  createServiceAccount(input: $input) {
    serviceAccount {
      id
      name
      isActive
      expiresAt
    }
  }
}

mutation CreateTenant($input: CreateTenantInput!) {
  createTenant(input: $input) {
    id
    isPaying
    members {
      id
      roles
    }
  }
}

query DashboardAnalytics($days: Int) {
  dashboardAnalytics(days: $days) {
    days
    generatedAt
    lastScanAt
    averageSecurityScore
    previousAverageSecurityScore
    severityCounts {
      severity
      count
    }
    previousSeverityCounts {
      severity
      count
    }
    exposure {
      total
      previousTotal
      newFindings
      resolvedFindings
      codeFindings
      dependencyFindings
      corroboratedFindings
      falsePositives
    }
  }
}

mutation DeclineInvitation($id: ID!) {
  declineInvitation(id: $id)
}

mutation DeleteGitEntity($id: ID!) {
  deleteGitEntity(id: $id)
}

mutation DeleteGitToken($id: ID!) {
  deleteGitToken(id: $id)
}

mutation DeleteInvitation($id: ID!) {
  deleteInvitation(id: $id)
}

mutation DeleteNetwork($id: ID!) {
  deleteNetwork(id: $id)
}

mutation DeleteNetworkScanResult($id: ID!) {
  deleteNetworkScanResult(id: $id)
}

mutation DeleteNotificationScope($id: ID!) {
  deleteNotificationScope(id: $id)
}

mutation DeletePaymentMethod($id: ID!) {
  deletePaymentMethod(id: $id)
}

mutation DeleteRepository($id: ID!) {
  deleteRepository(id: $id)
}

mutation DeleteScanResult($id: ID!) {
  deleteScanResult(id: $id)
}

mutation DeleteScanSchedule($id: ID!) {
  deleteScanSchedule(id: $id)
}

mutation DeleteServiceAccount($id: ID!) {
  deleteServiceAccount(id: $id)
}

mutation DeleteTenantMember($id: ID!) {
  deleteTenantMember(id: $id)
}

mutation DismissTask($id: ID!) {
  dismissTask(id: $id)
}

mutation DissociateGitTokenWithGitEntity($input: GitTokenAssociationInput!) {
  dissociateGitTokenWithGitEntity(input: $input)
}

query DockerScanTool($id: ID!) {
  dockerScanTool(id: $id) {
    id
    name
  }
}

query DockerScanTools($list: List) {
  dockerScanTools(list: $list) {
    total
    items {
      id
      name
    }
  }
}

mutation DowngradeToFree {
  downgradeToFree
}

mutation FetchRepositories($input: FetchRepositoriesInput!) {
  fetchRepositories(input: $input)
}

query FindingCorroboration($repositoryId: ID!) {
  findingCorroboration(repositoryId: $repositoryId) {
    total
    items {
      id
      matchHash
      toolCount
      severity
    }
  }
}

query FindingTriage($repositoryId: ID!) {
  findingTriage(repositoryId: $repositoryId) {
    id
    repositoryId
    matchKey
    findingType
    state
    justification
    response
    priority
  }
}

query FindingTriageHistory($repositoryId: ID!, $matchKey: String) {
  findingTriageHistory(repositoryId: $repositoryId, matchKey: $matchKey) {
    id
    repositoryId
    matchKey
    action
    state
    justification
    response
    priority
  }
}

query GitEntities($list: List) {
  gitEntities(list: $list) {
    total
  }
}

query GitEntity($id: ID!) {
  gitEntity(id: $id) {
    __typename
    ... on Organization {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
    ... on GitUser {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
  }
}

query GitEntityProviders($name: String!) {
  gitEntityProviders(name: $name)
}

query GitEntityRepositoryCount($name: String!, $gitType: GitType!) {
  gitEntityRepositoryCount(name: $name, gitType: $gitType)
}

query GitToken($id: ID!) {
  gitToken(id: $id) {
    id
    name
    value
    expiresAt
    flags
    status
    scopes
    createdAt
  }
}

query GitTokenExpiration($value: String!, $gitType: GitType!) {
  gitTokenExpiration(value: $value, gitType: $gitType)
}

query GitTokens($list: List) {
  gitTokens(list: $list) {
    total
    items {
      id
      name
      value
      expiresAt
      flags
      status
      scopes
      createdAt
    }
  }
}

query GitUser($id: ID!) {
  gitUser(id: $id) {
    __typename
    ... on Organization {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
    ... on GitUser {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
  }
}

query GitUsers($list: List) {
  gitUsers(list: $list) {
    total
  }
}

query Invitation($id: ID!) {
  invitation(id: $id) {
    id
    email
    tenantName
  }
}

query Invitations {
  invitations {
    id
    email
    tenantName
  }
}

mutation InviteTenantMember($input: InviteTeamMemberInput!) {
  inviteTenantMember(input: $input)
}

query Invoice($id: ID!) {
  invoice(id: $id) {
    id
    invoiceNumber
    date
    dueDate
    status
    total
    currency
  }
}

query Invoices($list: List) {
  invoices(list: $list) {
    total
    items {
      id
      invoiceNumber
      date
      dueDate
      status
      total
      currency
    }
  }
}

mutation MarkAllNotificationsRead {
  markAllNotificationsRead
}

mutation MarkNotificationDelivered($id: ID!) {
  markNotificationDelivered(id: $id)
}

mutation MarkNotificationsRead($ids: [ID!]!) {
  markNotificationsRead(ids: $ids)
}

query MyUser {
  myUser {
    id
    email
    name
    username
    tenants {
      id
      isPaying
    }
    preferences {
      theme
      dateTimeFormat
      repositoriesView
    }
  }
}

query Network($id: ID!) {
  network(id: $id) {
    id
    name
    network
    networkType
    tenant
    securityScore
    createdAt
    updatedAt
  }
}

query Networks($list: List) {
  networks(list: $list) {
    total
    items {
      id
      name
      network
      networkType
      tenant
      securityScore
      createdAt
      updatedAt
    }
  }
}

query NetworkScanFinding($id: ID!) {
  networkScanFinding(id: $id) {
    id
    scanResultId
    host
    hostname
    hostnameType
    protocol
    port
    serviceName
  }
}

query NetworkScanFindings($list: List) {
  networkScanFindings(list: $list) {
    total
    items {
      id
      scanResultId
      host
      hostname
      hostnameType
      protocol
      port
      serviceName
    }
  }
}

query NetworkScanResult($id: ID!) {
  networkScanResult(id: $id) {
    id
    networkId
    status
    createdAt
    updatedAt
    scanTime
    network {
      id
      name
      network
      networkType
      tenant
      securityScore
      createdAt
      updatedAt
    }
  }
}

query NetworkScanResults($list: List) {
  networkScanResults(list: $list) {
    total
    items {
      id
      networkId
      status
      createdAt
      updatedAt
      scanTime
    }
  }
}

query Notifications($list: List) {
  notifications(list: $list) {
    items {
      id
      type
      eventType
      data
      read
      createdAt
    }
    total
  }
}

subscription Notifications {
  notifications {
    id
    type
    eventType
    data
    read
    createdAt
  }
}

query NotificationScope($id: ID!) {
  notificationScope(id: $id) {
    id
    channelIds
    channelType
    scopes
    isActive
    status
    headers {
      name
      value
    }
    template
  }
}

query NotificationScopes($list: List) {
  notificationScopes(list: $list) {
    total
    items {
      id
      channelIds
      channelType
      scopes
      isActive
      status
      template
    }
  }
}

query Organization($id: ID!) {
  organization(id: $id) {
    __typename
    ... on Organization {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
    ... on GitUser {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
  }
}

query Organizations($list: List) {
  organizations(list: $list) {
    total
  }
}

query PaymentMethod($id: ID!) {
  paymentMethod(id: $id) {
    id
    default
    lastFour
    brand
    expiryMonth
    expiryYear
    cardholderName
    expired
  }
}

query PaymentMethods($list: List) {
  paymentMethods(list: $list) {
    total
    items {
      id
      default
      lastFour
      brand
      expiryMonth
      expiryYear
      cardholderName
      expired
    }
  }
}

query Plans {
  plans {
    id
    availableGitScanMinutes
    availableNetworkScanMinutes
    maxRepositories
    maxNetworks
    maxEmails
    pricePerGitScanMinute
    pricePerNetworkScanMinute
  }
}

query ProgrammingLanguages {
  programmingLanguages
}

query PromoGrants {
  promoGrants {
    id
    code
    startsAt
    endsAt
    gitScanMinutes
    networkScanMinutes
    maxRepositories
    maxNetworks
  }
}

mutation RedeemPromoCode($code: String!) {
  redeemPromoCode(code: $code) {
    id
    code
    startsAt
    endsAt
    gitScanMinutes
    networkScanMinutes
    maxRepositories
    maxNetworks
  }
}

mutation RegisterPushSubscription($input: PushSubscriptionInput!) {
  registerPushSubscription(input: $input)
}

query RemediationTemplate {
  remediationTemplate {
    codeIssueBody
    dependencyIssueBody
    pullRequestBody
  }
}

query Repositories($list: List) {
  repositories(list: $list) {
    total
    items {
      id
      gitEntityId
      repositoryName
      private
      securityScore
      programmingLanguage
      repositorySize
      numberOfBranches
    }
  }
}

query Repository($id: ID!) {
  repository(id: $id) {
    id
    gitEntityId
    repositoryName
    private
    securityScore
    programmingLanguage
    repositorySize
    numberOfBranches
  }
}

query RepositoryBranches($repositoryId: ID!) {
  repositoryBranches(repositoryId: $repositoryId)
}

query RepositoryDependencyScanFindingGroups($list: List) {
  repositoryDependencyScanFindingGroups(list: $list) {
    total
    items {
      id
      dependency
      repositoryId
      severity
      installedVersion
      occurrences
      issueUrl
      issueStatus
    }
  }
}

query RepositoryDependencyScanFindings($list: List) {
  repositoryDependencyScanFindings(list: $list) {
    total
    items {
      id
      commitScanId
      createdAt
      updatedAt
      severity
      vulnerability
      dependency
      installedVersion
    }
  }
}

mutation RequestNSFConsultation($input: NSFConsultation!) {
  requestNSFConsultation(input: $input)
}

mutation RequestRSFConsultation($input: RSFConsultation!) {
  requestRSFConsultation(input: $input)
}

mutation RetryPayment($invoiceId: ID!, $paymentMethodId: ID!) {
  retryPayment(invoiceId: $invoiceId, paymentMethodId: $paymentMethodId) {
    id
    invoiceNumber
    date
    dueDate
    status
    total
    currency
  }
}

mutation RevealScanFindingMatch($repositoryId: ID!, $matchHash: String!) {
  revealScanFindingMatch(repositoryId: $repositoryId, matchHash: $matchHash)
}

query ScanFindingGroups($list: List) {
  scanFindingGroups(list: $list) {
    total
    items {
      id
      fingerprint
      matchHash
      matchedByToolCount
      file
      severity
      confidence
      match
    }
  }
}

query ScanFindingMatchGroups($list: List) {
  scanFindingMatchGroups(list: $list) {
    total
    items {
      id
      matchHash
      file
      line
      severity
      confidence
      match
      occurrences
    }
  }
}

query ScanFindings($list: List) {
  scanFindings(list: $list) {
    total
    items {
      id
      commitScanId
      createdAt
      updatedAt
      line
      file
      severity
      confidence
    }
  }
}

query ScanResult($id: ID!) {
  scanResult(id: $id) {
    id
    repositoryId
    scanType
    scanner
    dockerScanToolId
    status
    createdAt
    updatedAt
  }
}

query ScanResults($list: List) {
  scanResults(list: $list) {
    total
    items {
      id
      repositoryId
      scanType
      scanner
      dockerScanToolId
      status
      createdAt
      updatedAt
    }
  }
}

query ScanSchedule($id: ID!) {
  scanSchedule(id: $id) {
    id
    action
    repositoryId
    gitEntityId
    branch
    dockerScanToolId
    frequency
    hourUtc
  }
}

query ScanSchedules($list: List) {
  scanSchedules(list: $list) {
    total
    items {
      id
      action
      repositoryId
      gitEntityId
      branch
      dockerScanToolId
      frequency
      hourUtc
    }
  }
}

query ServiceAccounts {
  serviceAccounts {
    id
    name
    isActive
    expiresAt
    createdBy {
      id
      email
      username
      name
    }
  }
}

mutation SetDefaultPaymentMethod($id: ID!) {
  setDefaultPaymentMethod(id: $id)
}

mutation SetFindingTriage($input: SetFindingTriageInput!) {
  setFindingTriage(input: $input) {
    id
    repositoryId
    matchKey
    findingType
    state
    justification
    response
    priority
  }
}

mutation SetGitEntityIgnorePaths($input: SetGitEntityIgnorePathsInput!) {
  setGitEntityIgnorePaths(input: $input) {
    __typename
    ... on Organization {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
    ... on GitUser {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
  }
}

mutation SetRemediationTemplate($input: RemediationTemplateInput!) {
  setRemediationTemplate(input: $input) {
    codeIssueBody
    dependencyIssueBody
    pullRequestBody
  }
}

mutation SetRepositoryEnabled($input: SetRepositoryEnabledInput!) {
  setRepositoryEnabled(input: $input)
}

mutation SetRepositoryIgnorePaths($input: SetRepositoryIgnorePathsInput!) {
  setRepositoryIgnorePaths(input: $input) {
    id
    gitEntityId
    repositoryName
    private
    securityScore
    programmingLanguage
    repositorySize
    numberOfBranches
  }
}

mutation SetServiceAccountActive($input: SetServiceAccountActiveInput!) {
  setServiceAccountActive(input: $input) {
    id
    name
    isActive
    expiresAt
    createdBy {
      id
      email
      username
      name
    }
  }
}

mutation StartNetworkScan($input: StartNetworkScanInput!) {
  startNetworkScan(input: $input)
}

mutation StartRepositoryScan($input: StartRepositoryScanInput!) {
  startRepositoryScan(input: $input) {
    id
    objectId
    status
    state {
      totalCommits
      scheduled
      scanned
      failed
      parsed
    }
    createdAt
    scanResult {
      id
      repositoryId
      scanType
      scanner
      dockerScanToolId
      status
      createdAt
      updatedAt
    }
  }
}

query Statistics {
  statistics {
    tenant
    totalUsers
    totalGitEntities
    totalRepositories
    totalNetworks
  }
}

query Task($id: ID!) {
  task(id: $id) {
    __typename
    ... on RepositoryScanTask {
      id
      objectId
      status
      createdAt
    }
    ... on NetworkScanTask {
      id
      objectId
      status
      createdAt
    }
  }
}

subscription TaskEvents {
  taskEvents {
    type
    taskId
  }
}

query Tasks {
  tasks {
    __typename
    ... on RepositoryScanTask {
      id
      objectId
      status
      createdAt
    }
    ... on NetworkScanTask {
      id
      objectId
      status
      createdAt
    }
  }
}

mutation TestNotificationScope($id: ID!) {
  testNotificationScope(id: $id) {
    id
    channelIds
    channelType
    scopes
    isActive
    status
    headers {
      name
      value
    }
    template
  }
}

mutation TransferGitEntity($input: TransferGitEntityInput!) {
  transferGitEntity(input: $input)
}

mutation TransferNetwork($input: TransferNetworkInput!) {
  transferNetwork(input: $input)
}

query UnreadNotificationCount {
  unreadNotificationCount
}

mutation UnregisterPushSubscription($endpoint: String!) {
  unregisterPushSubscription(endpoint: $endpoint)
}

mutation UpdateGitEntity($input: UpdateGitEntityInput!) {
  updateGitEntity(input: $input) {
    __typename
    ... on Organization {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
    ... on GitUser {
      id
      name
      gitType
      externalId
      webUrl
      htmlUrl
      avatarUrl
      color
    }
  }
}

mutation UpdateGitToken($input: UpdateGitTokenInput!) {
  updateGitToken(input: $input) {
    id
    name
    value
    expiresAt
    flags
    status
    scopes
    createdAt
  }
}

mutation UpdateMyUserPreferences($input: UpdateUserPreferencesInput!) {
  updateMyUserPreferences(input: $input) {
    theme
    dateTimeFormat
    repositoriesView
  }
}

mutation UpdateNotificationScope($input: UpdateNotificationScopeInput!) {
  updateNotificationScope(input: $input) {
    id
    channelIds
    channelType
    scopes
    isActive
    status
    headers {
      name
      value
    }
    template
  }
}

mutation UpdateScanSchedule($input: UpdateScanScheduleInput!) {
  updateScanSchedule(input: $input) {
    id
    action
    repositoryId
    gitEntityId
    branch
    dockerScanToolId
    frequency
    hourUtc
  }
}

mutation UpdateUserRoles($input: UpdateUserRolesInput!) {
  updateUserRoles(input: $input) {
    id
    roles
    user {
      id
      email
      username
      name
    }
  }
}

mutation UpgradeToPaying {
  upgradeToPaying
}

query Usage($startDate: DateTime!, $endDate: DateTime!) {
  usage(startDate: $startDate, endDate: $endDate) {
    accountTier
    usedGitScanTimeMinutes
    repositoryScanLimited
    usedNetworkScanTimeMinutes
    networkScanLimited
    parallelScans
    availableGitScanMinutes
    availableNetworkScanMinutes
  }
}

query WorkspaceOverview($gitEntityId: ID!) {
  workspaceOverview(gitEntityId: $gitEntityId) {
    severityCounts {
      severity
      count
    }
    totalFindings
    totalRepositories
    scanned
    unscanned
  }
}