Using the PointFive API

query ListOpportunities {
  opportunities(
    where: {
      status: { IN: [OPEN, IN_PROGRESS] }
      savingAmount: { GTE: 100 }
      definitionCategory: { IN: [unused_resource, underutilization] }
    }
    limit: 20
    offset: 0
    orderBy: [{ savingAmount: DESC }]
  ) {
    id
    name
    savingAmount
    currentCost
    priority
    risk
    effort
    status
    resource {
      name
      provider
      service
      region
    }
  }
}

query GetOpportunity {
  opportunity(id: "opportunity-uuid") {
    id
    name
    diagnosis {
      description
      descriptionText
      data
    }
    recommendation {
      summary
      summaryText
    }
    savingAmount
    currentCost
    priority
    risk
    effort
    status
    resource {
      id
      name
      provider
      service
      region
      tags
    }
    remediationLinks {
      name
      url
    }
    platformUrl
  }
}

mutation {generateOpportunitiesExportAsset( 
selectedColumns: [String!] 
filter: OpportunitiesFilterInput 
exportType: ExportType! ): ExportAsset!
}

mutation {generateResourcesExportAsset( 
selectedColumns: [String!] 
filter: ResourceFilterInput 
orderBy: [ResourceOrdering!] 
exportType: ExportType! ): ExportAsset! 
}

type Query {   
"""   Get an export asset by ID. Returns null if not found or expired.   Client should poll this endpoint until status is COMPLETED or FAILED.   """   
exportAsset(id: UUID!): ExportAsset }

enum ExportType {   
CSV   
JSON 
}  

enum ExportAssetStatus {   
PENDING      # Export request received, not yet processing   
PROCESSING   # Export is being generated   
COMPLETED    # Export is ready for download   
FAILED       # Export failed (check logs or retry) 
}  

type ExportAsset {   
id: UUID!   
exportFormat: ExportType!   
status: ExportAssetStatus!   
url: String                    # Download URL (only available when status = COMPLETED)   
createdAt: Time!   
expiresAt: Time! 
}

mutation {
  generateOpportunitiesExportAsset(
    selectedColumns: [
      "id",
      "name",
      "projectId",
      "resourceId",
      "savingAmount",
      "currentCost",
      "priority",
      "status",
      "createdAt"
    ]
    filter: {
      priority: { gte: 7.0 }
      createdAtRelative: { unit: DAYS, value: 30, direction: PAST }
    }
    exportType: CSV
  ) {
    id
    status
    exportFormat
    createdAt
    expiresAt
  }
}

mutation {
  generateResourcesExportAsset(
    selectedColumns: [
      "id",
      "name",
      "resourceId",
      "service",
      "region",
      "cost",
      "monthlySavings",
      "projectId"
    ]
    filter: {
      service: { eq: "EC2" }
      monthlySavings: { gt: 0 }
    }
    orderBy: [
      { monthlySavings: DESC }
    ]
    exportType: CSV
  ) {
    id
    status
    exportFormat
    createdAt
    expiresAt
  }
}

{
  "data": {
    "exportAsset": {
      "id": "d7d59999-642a-400e-b85c-700ed0ee5363",
      "status": "COMPLETED",
      "url": "your download url",
      "exportFormat": "CSV",
      "createdAt": "2026-01-06T12:49:40.755168Z",
      "expiresAt": "2026-01-13T12:49:40.753742Z"
    }
  }
}

mutation BatchImportTeams($input: BatchImportTeamsInput!) {
  batchImportTeams(input: $input) {
    success
    importedTeamIds
  }
}

service: { IN: ["EC2", "RDS", "S3"] }
region: { ILIKE: "us-%" }  # Matches us-east-1, us-west-2, etc.

tag: {
  IN: [
    { key: "Environment", value: "Production" },
    { key: "Environment", value: "Staging" }
  ]
}
tag: { HasKey: "Team" }  # Any resource with a "Team" tag

resourceGroup: {
  IN: [
    { name: "production-rg", subscriptionId: "abc123" }
  ]
}

project: {
  name: { ILIKE: "prod-%" }
  managementAccountId: { IN: ["123456789012"] }
}

AND: [
  { service: { IN: ["EC2"] } },
  { region: { IN: ["us-east-1"] } },
  { tag: { HasKey: "CostCenter" } }
]

mutation {
  batchImportTeams(input: {
    teams: [
      {
        name: "Engineering"
        members: [
          "550e8400-e29b-41d4-a716-446655440001",
          "550e8400-e29b-41d4-a716-446655440002"
        ]
      },
      {
        name: "Marketing"
        members: [
          "550e8400-e29b-41d4-a716-446655440003"
        ]
      }
    ]
  }) {
    success
    importedTeamIds
  }
}

mutation {
  batchImportTeams(input: {
    teams: [
      {
        name: "Engineering"
        resourceAllocationRules: [
          {
            name: "All Engineering Resources"
            rule: {
              tag: {
                IN: [
                  { key: "Department", value: "Engineering" }
                ]
              }
            }
          }
        ]
      },
      {
        name: "Backend Team"
        parentName: "Engineering"
        members: [
          "550e8400-e29b-41d4-a716-446655440001",
          "550e8400-e29b-41d4-a716-446655440002"
        ]
        resourceAllocationRules: [
          {
            name: "Backend Production Services"
            rule: {
              AND: [
                {
                  service: { IN: ["EC2", "RDS", "ElastiCache"] }
                },
                {
                  tag: {
                    IN: [
                      { key: "Environment", value: "Production" },
                      { key: "Team", value: "Backend" }
                    ]
                  }
                }
              ]
            }
          }
        ]
      },
      {
        name: "Frontend Team"
        parentName: "Engineering"
        members: [
          "550e8400-e29b-41d4-a716-446655440003"
        ]
        resourceAllocationRules: [
          {
            name: "Frontend Resources"
            rule: {
              AND: [
                {
                  service: { IN: ["S3", "CloudFront", "Lambda"] }
                },
                {
                  tag: {
                    HasKey: "Frontend"
                  }
                }
              ]
            }
          }
        ]
      }
    ]
  }) {
    success
    importedTeamIds
  }
}

mutation {
  batchImportTeams(input: {
    teams: [
      {
        name: "US Operations"
        resourceAllocationRules: [
          {
            name: "US Regions"
            rule: {
              region: {
                ILIKE: "us-%"
              }
            }
          }
        ]
      },
      {
        name: "EU Operations"
        resourceAllocationRules: [
          {
            name: "EU Regions"
            rule: {
              region: {
                ILIKE: "eu-%"
              }
            }
          }
        ]
      },
      {
        name: "APAC Operations"
        resourceAllocationRules: [
          {
            name: "APAC Regions"
            rule: {
              region: {
                IN: ["ap-southeast-1", "ap-northeast-1", "ap-south-1"]
              }
            }
          }
        ]
      }
    ]
  }) {
    success
    importedTeamIds
  }
}

mutation {
  batchImportTeams(input: {
    teams: [
      {
        name: "Production Account Team"
        resourceAllocationRules: [
          {
            name: "Production Account Resources"
            rule: {
              AND: [
                {
                  managementAccountId: { IN: ["123456789012"] }
                },
                {
                  tag: {
                    IN: [
                      { key: "Environment", value: "Production" }
                    ]
                  }
                }
              ]
            }
          }
        ]
      },
      {
        name: "Development Account Team"
        resourceAllocationRules: [
          {
            name: "Dev Account Resources"
            rule: {
              managementAccountId: { IN: ["987654321098"] }
            }
          }
        ]
      }
    ]
  }) {
    success
    importedTeamIds
  }
}

mutation {
  batchImportTeams(input: {
    teams: [
      {
        name: "Database Team"
        members: [
          "550e8400-e29b-41d4-a716-446655440010"
        ]
        resourceAllocationRules: [
          {
            name: "Critical Databases"
            rule: {
              OR: [
                {
                  resourceId: {
                    IN: [
                      "arn:aws:elasticache:us-east-1:587752543875:replicationgroup:pointfive-graphql",
                      "arn:aws:rds:us-east-1:587752543875:db:production-primary"
                    ]
                  }
                },
                {
                  AND: [
                    {
                      service: { IN: ["RDS", "ElastiCache", "DynamoDB"] }
                    },
                    {
                      tag: {
                        IN: [
                          { key: "Tier", value: "Critical" }
                        ]
                      }
                    }
                  ]
                }
              ]
            }
          }
        ]
      }
    ]
  }) {
    success
    importedTeamIds
  }
}

mutation {
  batchImportTeams(input: {
    removeExistingStructure: true
    teams: [
      {
        name: "Executive"
        members: ["550e8400-e29b-41d4-a716-446655440001"]
      },
      {
        name: "Engineering"
        parentName: "Executive"
        resourceAllocationRules: [
          {
            name: "Engineering Tagged Resources"
            rule: {
              tag: {
                HasKey: "Engineering"
              }
            }
          }
        ]
      },
      {
        name: "Sales"
        parentName: "Executive"
        resourceAllocationRules: [
          {
            name: "Sales Tagged Resources"
            rule: {
              tag: {
                HasKey: "Sales"
              }
            }
          }
        ]
      }
    ]
  }) {
    success
    importedTeamIds
  }
}Example 7: Azure Resource Groups

mutation {
  batchImportTeams(input: {
    teams: [
      {
        name: "Production Infrastructure"
        resourceAllocationRules: [
          {
            name: "Production Resource Groups"
            rule: {
              resourceGroup: {
                IN: [
                  {
                    name: "production-rg"
                    subscriptionId: "abc123-def456-ghi789"
                  },
                  {
                    name: "prod-networking-rg"
                    subscriptionId: "abc123-def456-ghi789"
                  }
                ]
              }
            }
          }
        ]
      }
    ]
  }) {
    success
    importedTeamIds
  }
}

query GetTeam {
  getTeam(id: "team-uuid-here") {
    id
    name
    type
    members {
      userId
      user {
        firstName
        lastName
        email
      }
    }
    memberCount
    childTeams {
      id
      name
    }
    parentTeams {
      id
      name
    }
    resourceAllocationRules {
      name
      rule
    }
    createdAt
    updatedAt
  }
}

query ListTeams {
  listTeams(
    where: { name: { contains: "Engineering" }, type: TEAM, orphan: false }
    limit: 50
    offset: 0
  ) {
    id
    name
    type
    memberCount
    resourceAllocationRulesCount
    createdAt
  }
}

mutation CreateTeam {
  createTeam(input: { name: "Platform Engineering", members: ["user-uuid-1", "user-uuid-2"] }) {
    id
    name
    type
    members {
      userId
      user {
        firstName
        lastName
      }
    }
    createdAt
  }
}

mutation UpdateTeam {
  updateTeam(
    id: "team-uuid-here"
    input: {
      name: "Updated Team Name"
      ResourceAllocationRules: [
        {
          name: "Production Resources"
          rule: { AND: [{ tag: { IN: { Key: "Environment", Values: ["production"] } } }] }
        }
      ]
    }
  ) {
    success
    team {
      id
      name
      resourceAllocationRules {
        name
        rule
      }
    }
  }
}

mutation AddMembers {
  addMembersToTeam(id: "team-uuid-here", userIds: ["user-uuid-1", "user-uuid-2"]) {
    success
  }
}

mutation RemoveFromTeams {
  removeMemberFromTeams(userId: "user-uuid-here", teamIds: ["team-uuid-1", "team-uuid-2"]) {
    success
  }
}

# Add child teams
mutation AddChildTeams {
  addChildTeamsToTeam(
    id: "parent-team-uuid"
    childTeamIds: ["child-team-uuid-1", "child-team-uuid-2"]
  ) {
    success
  }
}

# Remove child teams
mutation RemoveChildTeams {
  removeChildTeamsFromTeam(
id: "parent-team-uuid", childTeamIds: ["child-team-uuid-1"]) {
    success
  }
}

mutation DeleteTeam {
  deleteTeam(
    id: "team-uuid"
    deleteSubTeams: false
  ) {
    deleteCount
  }
}

{
  name: "Production Environment"
  rule: {
    AND: [
      { tag: { IN: { Key: "Environment", Values: ["production"] } } }
      { tag: { IN: { Key: "Team", Values: ["platform"] } } }
    ]
  }
}

{
  name: "US Regions"
  rule: {
    AND: [{ region: { IN: ["us-east-1", "us-west-2"] } }]
  }
}

{
  name: "Development or Staging"
  rule: {
    AND: [
      {
        OR: [
          { tag: { IN: { Key: "Environment", Values: ["development"] } } }
          { tag: { IN: { Key: "Environment", Values: ["staging"] } } }
        ]
      }
    ]
  }
}

query ListUsers {
  users(
    search: "john"
    where: { role: { in: [ADMIN] }, email: { contains: "@example.com" } }
    order: [{ lastName: ASC }, { firstName: ASC }]
    offset: 0
    limit: 50
  ) {
    id
    email
    firstName
    lastName
    fullName
    role
    teams {
      id
      name
    }
    lastLoginAt
    createdAt
  }
}

mutation CreateUsers {
  createUser(
    input: [
      {
        email: "[email protected]"
        firstName: "John"
        lastName: "Doe"
        role: MEMBER
        teams: [{ id: "team-uuid-here" }]
        remoteAssistanceConsent: true
        silentMode: false
      }
    ]
  ) {
    success
    users {
      id
      email
      firstName
      lastName
      fullName
      role
      teams {
        id
        name
      }
    }
  }
}

mutation UpdateUser {
  updateUser(
    userId: "user-uuid-here"
    input: { firstName: "Jane", lastName: "Smith", role: ADMIN, remoteAssistanceConsent: true }
  ) {
    success
    user {
      id
      firstName
      lastName
      role
    }
  }
}

mutation DeleteUser {
  deleteUser(userId: "user-uuid-here") {
    success
    user {
      id
      email
      firstName
      lastName
    }
  }
}

# First page
query FirstPage {
  opportunities(limit: 20, offset: 0) {
    id
    name
  }
}

# Second page
query SecondPage {
  opportunities(limit: 20, offset: 20) {
    id
    name
  }
}

name: {
  EQ: "Exact match"
  LIKE: "Contains (case-sensitive)"
  ILIKE: "contains (case-insensitive)"
  IN: ["value1", "value2"]
}

savingAmount: {
  GT: 100        # Greater than
  GTE: 100       # Greater than or equal
  LT: 1000       # Less than
  LTE: 1000      # Less than or equal
  EQ: 500        # Equal
}

createdAt: {
  GTE: "2024-01-01T00:00:00Z"
  LTE: "2024-12-31T23:59:59Z"
}

where: {
  OR: [
    { savingAmount: { GTE: 1000 } }
    { 
      AND: [
        { savingAmount: { GTE: 500 } }
        { risk: { LTE: 3 } }
      ]
    }
  ]
  NOT: { status: { EQ: DISMISSED } }
}

{
  "errors": [
    {
      "message": "Error description",
      "path": ["fieldName"],
      "extensions": {
        "code": "ERROR_CODE"
      }
    }
  ]
}

## Common Patterns

### 1. Creating a Complete Team Structure

```graphql
# Step 1: Create parent team
mutation {
  engineering: createTeam(input: { name: "Engineering" }) {
    id
  }
}

# Step 2: Create child teams
mutation {
  backend: createTeam(input: { name: "Backend Team" }) {
    id
  }
  frontend: createTeam(input: { name: "Frontend Team" }) {
    id
  }
}

# Step 3: Establish hierarchy
mutation {
  addChildTeamsToTeam(id: "engineering-uuid", childTeamIds: ["backend-uuid", "frontend-uuid"]) {
    success
  }
}

# Step 4: Add members
mutation {
  addMembersToTeam(id: "backend-uuid", userIds: ["user1-uuid", "user2-uuid"]) {
    success
  }
}

mutation BulkCreateUsers {
  createUser(
    input: [
      {
        email: "[email protected]"
        firstName: "Developer"
        lastName: "One"
        role: MEMBER
        teams: [{ id: "backend-team-uuid" }]
        remoteAssistanceConsent: true
      }
      {
        email: "[email protected]"
        firstName: "Developer"
        lastName: "Two"
        role: MEMBER
        teams: [{ id: "frontend-team-uuid" }]
        remoteAssistanceConsent: true
      }
    ]
  ) {
    success
    users {
      id
      email
      teams {
        name
      }
    }
  }
}

# Query opportunities with filters
query FindHighValueOpportunities {
  opportunities(
    where: {
      status: { EQ: OPEN }
      savingAmount: { GTE: 500 }
      risk: { LTE: 3 }
    }
    orderBy: [{ savingAmount: DESC }]
    limit: 20
  ) {
    id
    name
    savingAmount
    risk
    resource {
      name
      service
    }
  }
}

# Export filtered opportunities
query ExportOpportunities {
  opportunitiesExport(
    where: {
      status: { EQ: OPEN }
      savingAmount: { GTE: 500 }
    }
    exportType: CSV
  )
}