GraphQL API

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

mutation AcceptRisk($id: ID!, $input: AcceptRiskInput!) {
  acceptRisk(id: $id, input: $input) {
    id
    reference
    title
    scenario
    category
    status
    owner
    treatment
  }
}

mutation AcceptTerms($version: String!) {
  acceptTerms(version: $version) {
    currentVersion
    currentUrl
    acceptedVersion
    acceptedBy
    acceptedAt
    isCurrent
  }
}

mutation AddRiskAction($id: ID!, $input: RiskActionInput!) {
  addRiskAction(id: $id, input: $input) {
    id
    description
    owner
    dueAt
    status
    issueUrl
    completedAt
    createdAt
  }
}

mutation AddWebTargetSignInMethod($input: AddWebTargetSignInMethodInput!) {
  addWebTargetSignInMethod(input: $input) {
    id
    name
    baseUrl
    scheme
    host
    port
    scopePaths
    excludedPaths
  }
}

mutation AssessRisk($id: ID!, $input: AssessRiskInput!) {
  assessRisk(id: $id, input: $input) {
    id
    kind
    likelihood
    impact
    score
    level
    rationale
    assessedBy
  }
}

query AssetContext($targetType: RiskLinkTarget, $targetIds: [ID!]) {
  assetContext(targetType: $targetType, targetIds: $targetIds) {
    targetType
    targetId
    businessCriticality
    environment
    dataClassification
    owner
    updatedBy
    updatedAt
  }
}

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
    scopes
  }
}

mutation ClearDastFindingTriage($webTargetId: ID!, $matchKey: String!) {
  clearDastFindingTriage(webTargetId: $webTargetId, matchKey: $matchKey)
}

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

mutation ClearWebTargetCredentials($input: ClearWebTargetCredentialsInput!) {
  clearWebTargetCredentials(input: $input) {
    id
    name
    baseUrl
    scheme
    host
    port
    scopePaths
    excludedPaths
  }
}

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 CreateRisk($input: CreateRiskInput!) {
  createRisk(input: $input) {
    id
    reference
    title
    scenario
    category
    status
    owner
    treatment
  }
}

mutation CreateScanSchedule($input: CreateScanScheduleInput!) {
  createScanSchedule(input: $input) {
    id
    action
    repositoryId
    gitEntityId
    webTargetId
    networkId
    branch
    category
  }
}

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

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

mutation CreateWebTarget($input: CreateWebTargetInput!) {
  createWebTarget(input: $input) {
    id
    name
    baseUrl
    scheme
    host
    port
    scopePaths
    excludedPaths
  }
}

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
    }
  }
}

query DastFinding($id: ID!) {
  dastFinding(id: $id) {
    id
    scanResultId
    templateId
    name
    severity
    category
    matchedAt
    host
  }
}

query DastFindings($list: List) {
  dastFindings(list: $list) {
    total
    items {
      id
      scanResultId
      templateId
      name
      severity
      category
      matchedAt
      host
    }
  }
}

query DastFindingTriage($webTargetId: ID!) {
  dastFindingTriage(webTargetId: $webTargetId) {
    id
    webTargetId
    matchKey
    state
    justification
    response
    priority
    reason
  }
}

query DastFindingTriageHistory($webTargetId: ID!, $matchKey: String) {
  dastFindingTriageHistory(webTargetId: $webTargetId, matchKey: $matchKey) {
    id
    webTargetId
    matchKey
    action
    state
    justification
    response
    priority
  }
}

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 DeleteRisk($id: ID!) {
  deleteRisk(id: $id)
}

mutation DeleteRiskAction($id: ID!, $actionId: ID!) {
  deleteRiskAction(id: $id, actionId: $actionId)
}

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 DeleteWebTarget($id: ID!) {
  deleteWebTarget(id: $id)
}

mutation DeprovisionNetworkAgent($input: DeprovisionNetworkAgentInput!) {
  deprovisionNetworkAgent(input: $input)
}

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

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

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

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

mutation DowngradeToFree {
  downgradeToFree
}

query ExploitedFindings($epssMin: Float, $limit: Int) {
  exploitedFindings(epssMin: $epssMin, limit: $limit) {
    items {
      targetType
      targetId
      targetName
      findingType
      matchKey
      title
      installedVersion
      fixedVersion
    }
    total
    kevCount
    epssMin
    kevSyncedAt
    epssSyncedAt
    epssDate
  }
}

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

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

query FindingTriage($repositoryId: ID!, $matchKey: String) {
  findingTriage(repositoryId: $repositoryId, matchKey: $matchKey) {
    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 LinkRisk($id: ID!, $input: LinkRiskInput!) {
  linkRisk(id: $id, input: $input) {
    id
    targetType
    targetId
    matchKey
    findingType
    title
    severity
    createdBy
  }
}

mutation MarkAllNotificationsRead {
  markAllNotificationsRead
}

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

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

query MyAiAccess {
  myAiAccess
}

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 ProvisionNetworkAgent($input: ProvisionNetworkAgentInput!) {
  provisionNetworkAgent(input: $input) {
    agent {
      id
      status
      lastSeenAt
      createdAt
      routeApproved
    }
    preauthKey
    installCommand
  }
}

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

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

mutation RemediateDependencyFinding($input: RemediateFindingInput!) {
  remediateDependencyFinding(input: $input)
}

mutation RemediateScanFinding($input: RemediateFindingInput!) {
  remediateScanFinding(input: $input)
}

query RemediationTemplate {
  remediationTemplate {
    codeIssueBody
    dependencyIssueBody
    pullRequestBody
  }
}

mutation RemoveWebTargetSignInMethod($webTargetId: ID!, $methodId: ID!) {
  removeWebTargetSignInMethod(webTargetId: $webTargetId, methodId: $methodId) {
    id
    name
    baseUrl
    scheme
    host
    port
    scopePaths
    excludedPaths
  }
}

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 RepositoryDependencyScanFindingGroupFacetCounts($list: List) {
  repositoryDependencyScanFindingGroupFacetCounts(list: $list) {
    severity {
      severity
      count
    }
    issueState {
      issueState
      count
    }
  }
}

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
      category
      vulnerability
      dependency
    }
  }
}

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)
}

mutation ReviewRisk($id: ID!, $input: ReviewRiskInput!) {
  reviewRisk(id: $id, input: $input) {
    id
    reference
    title
    scenario
    category
    status
    owner
    treatment
  }
}

mutation RevokeRiskAcceptance($id: ID!) {
  revokeRiskAcceptance(id: $id) {
    id
    reference
    title
    scenario
    category
    status
    owner
    treatment
  }
}

query Risk($id: ID!) {
  risk(id: $id) {
    id
    reference
    title
    scenario
    category
    status
    owner
    treatment
  }
}

query RiskRegisterExport {
  riskRegisterExport {
    contentType
    content
  }
}

query Risks($filter: RiskFilter, $skip: Int, $limit: Int) {
  risks(filter: $filter, skip: $skip, limit: $limit) {
    items {
      id
      reference
      title
      scenario
      category
      status
      owner
      treatment
    }
    total
  }
}

query RiskSettings {
  riskSettings {
    levelCriteria {
      level
      acceptRole
      maxDays
      reviewDays
    }
    requireDistinctAcceptor
    requireAcceptedRiskForWillNotFix
    autoDraftExploitedRisks
    updatedBy
    updatedAt
  }
}

query RiskSummary {
  riskSummary {
    total
    open
    byStatus {
      status
      count
    }
    byLevel {
      level
      count
    }
    inherentMatrix {
      likelihood
      impact
      count
    }
    residualMatrix {
      likelihood
      impact
      count
    }
    reviewOverdue
    acceptancesExpiring
  }
}

mutation SaveAssetContext($input: AssetContextInput!) {
  saveAssetContext(input: $input) {
    targetType
    targetId
    businessCriticality
    environment
    dataClassification
    owner
    updatedBy
    updatedAt
  }
}

mutation SaveRiskSettings($input: RiskSettingsInput!) {
  saveRiskSettings(input: $input) {
    levelCriteria {
      level
      acceptRole
      maxDays
      reviewDays
    }
    requireDistinctAcceptor
    requireAcceptedRiskForWillNotFix
    autoDraftExploitedRisks
    updatedBy
    updatedAt
  }
}

query ScanCategories {
  scanCategories
}

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

query ScanFindingMatchGroupFacetCounts($list: List) {
  scanFindingMatchGroupFacetCounts(list: $list) {
    severity {
      severity
      count
    }
    issueState {
      issueState
      count
    }
  }
}

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
    dockerScanToolId
    status
    createdAt
    updatedAt
    scanTime
  }
}

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

query ScanSchedule($id: ID!) {
  scanSchedule(id: $id) {
    id
    action
    repositoryId
    gitEntityId
    webTargetId
    networkId
    branch
    category
  }
}

query ScanSchedules($list: List) {
  scanSchedules(list: $list) {
    total
    items {
      id
      action
      repositoryId
      gitEntityId
      webTargetId
      networkId
      branch
      category
    }
  }
}

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

mutation SetDastFindingTriage($input: SetDastFindingTriageInput!) {
  setDastFindingTriage(input: $input) {
    id
    webTargetId
    matchKey
    state
    justification
    response
    priority
    reason
  }
}

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 SetWebTargetCredentials($input: SetWebTargetCredentialsInput!) {
  setWebTargetCredentials(input: $input) {
    id
    name
    baseUrl
    scheme
    host
    port
    scopePaths
    excludedPaths
  }
}

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

mutation StartRepositoryCategoryScan($input: StartRepositoryCategoryScanInput!) {
  startRepositoryCategoryScan(input: $input) {
    category
    taskId
    scanResultIds
    requested
    queued
    skipped {
      reason
    }
  }
}

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

mutation StartWebScan($input: StartWebScanInput!) {
  startWebScan(input: $input) {
    id
    objectId
    status
    state {
      totalHosts
      processedHosts
      currentHost
    }
    createdAt
    webScanResult {
      id
      webTargetId
      status
      securityScore
      scanTime
      pinnedAddresses
      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
    }
  }
}

query TenantPosture {
  tenantPosture {
    averageSecurityScore
    severityCounts {
      severity
      count
    }
  }
}

query TermsAcceptance {
  termsAcceptance {
    currentVersion
    currentUrl
    acceptedVersion
    acceptedBy
    acceptedAt
    isCurrent
  }
}

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 TriageExceptions($expiringWithinDays: Int) {
  triageExceptions(expiringWithinDays: $expiringWithinDays) {
    targetType
    targetId
    targetName
    matchKey
    findingType
    state
    justification
    response
  }
}

mutation UnlinkRisk($id: ID!, $linkId: ID!) {
  unlinkRisk(id: $id, linkId: $linkId)
}

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 UpdateRisk($id: ID!, $input: UpdateRiskInput!) {
  updateRisk(id: $id, input: $input) {
    id
    reference
    title
    scenario
    category
    status
    owner
    treatment
  }
}

mutation UpdateRiskAction($id: ID!, $actionId: ID!, $input: UpdateRiskActionInput!) {
  updateRiskAction(id: $id, actionId: $actionId, input: $input) {
    id
    description
    owner
    dueAt
    status
    issueUrl
    completedAt
    createdAt
  }
}

mutation UpdateScanSchedule($input: UpdateScanScheduleInput!) {
  updateScanSchedule(input: $input) {
    id
    action
    repositoryId
    gitEntityId
    webTargetId
    networkId
    branch
    category
  }
}

mutation UpdateUserAiAccess($input: UpdateUserAiAccessInput!) {
  updateUserAiAccess(input: $input) {
    id
    roles
    aiAccess
    user {
      id
      email
      username
      name
    }
  }
}

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

mutation UpgradeToPaying {
  upgradeToPaying
}

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

query WebScanResult($id: ID!) {
  webScanResult(id: $id) {
    id
    webTargetId
    status
    securityScore
    scanTime
    pinnedAddresses
    createdAt
    updatedAt
  }
}

query WebScanResults($list: List) {
  webScanResults(list: $list) {
    total
    items {
      id
      webTargetId
      status
      securityScore
      scanTime
      pinnedAddresses
      createdAt
      updatedAt
    }
  }
}

query WebTarget($id: ID!) {
  webTarget(id: $id) {
    id
    name
    baseUrl
    scheme
    host
    port
    scopePaths
    excludedPaths
  }
}

query WebTargets($list: List) {
  webTargets(list: $list) {
    total
    items {
      id
      name
      baseUrl
      scheme
      host
      port
      scopePaths
      excludedPaths
    }
  }
}

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