Skip to main content
Use GraphQL mutations to create, update, and delete data in the Manifest API. All mutations require authentication and appropriate permissions.

Asset mutations

Add asset

mutation {
  addAsset(
    input: {
      name: "Pump A-101"
      tag: "P-101"
      assetClassId: 123
      locationId: 456
      description: "Primary circulation pump"
    }
  ) {
    id
    name
    tag
  }
}

Update asset

mutation {
  updateAsset(
    id: 123
    input: {
      name: "Pump A-101 Updated"
      description: "Updated description"
    }
  ) {
    id
    name
    description
  }
}

Archive asset

mutation {
  archiveAsset(id: 123) {
    id
    status
  }
}

Delete asset

mutation {
  deleteAsset(id: 123)
}

Asset class mutations

Add asset class

mutation {
  addAssetClass(
    input: {
      name: "Centrifugal Pump"
      description: "Standard centrifugal pump"
      frontFace: FRONT
    }
  ) {
    id
    name
    description
  }
}

Update asset class

mutation {
  updateAssetClass(
    id: 123
    input: {
      name: "Updated name"
      description: "Updated description"
    }
  ) {
    id
    name
  }
}

Add model to asset class

mutation {
  addAssetClassModel(
    assetClassId: 123
    input: {
      fileId: 456
      scale: 1.0
    }
  ) {
    id
    fileId
  }
}

Delete asset class

mutation {
  deleteAssetClass(id: 123)
}

Job mutations

Add job

mutation {
  addJob(
    input: {
      name: "Maintenance inspection"
      templateId: 123
      assetId: 456
      priority: HIGH
      assignedUserIds: [789]
    }
  ) {
    id
    name
    status
    priority
  }
}

Update job

mutation {
  updateJob(
    id: 123
    input: {
      name: "Updated job name"
      priority: MEDIUM
    }
  ) {
    id
    name
    priority
  }
}

Start job

mutation {
  startJob(id: 123) {
    id
    status
    startedAt
  }
}

Complete job

mutation {
  completeJob(id: 123) {
    id
    status
    completedAt
  }
}

Assign user to job

mutation {
  assignUserToJob(
    jobId: 123
    userId: 456
  ) {
    id
    assignedUsers {
      id
      firstName
      lastName
    }
  }
}

Add note to job

mutation {
  addJobNote(
    input: {
      jobId: 123
      stepId: 456
      content: "Note content"
      type: TEXT
    }
  ) {
    id
    content
    createdAt
  }
}

Cancel job

mutation {
  cancelJob(id: 123) {
    id
    status
  }
}

Template mutations

Add template

mutation {
  addTemplate(
    input: {
      name: "Inspection procedure"
      description: "Standard inspection"
      type: PROCEDURE
    }
  ) {
    id
    name
    description
  }
}

Update template

mutation {
  updateTemplate(
    id: 123
    input: {
      name: "Updated template name"
      description: "Updated description"
    }
  ) {
    id
    name
  }
}

Copy template

mutation {
  copyTemplate(
    id: 123
    name: "Copy of template"
  ) {
    id
    name
  }
}

Delete template

mutation {
  deleteTemplate(id: 123)
}

Template version mutations

Create template version

mutation {
  createTemplateVersion(
    input: {
      templateId: 123
      versionName: "v1.0"
    }
  ) {
    id
    versionName
    state
  }
}

Update template version

mutation {
  updateTemplateVersion(
    id: 123
    input: {
      versionName: "v1.1"
    }
  ) {
    id
    versionName
  }
}

Edit version state

mutation {
  editVersionState(
    input: {
      versionId: 123
      state: PUBLISHED
    }
  ) {
    id
    state
  }
}

Location mutations

Add location

mutation {
  addLocation(
    input: {
      name: "Building A"
      address: "123 Main St"
      latitude: 40.7128
      longitude: -74.0060
      parentLocationId: 456
    }
  ) {
    id
    name
    address
  }
}

Update location

mutation {
  updateLocation(
    id: 123
    input: {
      name: "Building A - Updated"
      address: "123 Main St, Floor 2"
    }
  ) {
    id
    name
  }
}

Delete location

mutation {
  deleteLocation(id: 123)
}

User mutations

Update user

mutation {
  updateUser(
    id: 123
    input: {
      firstName: "John"
      lastName: "Doe"
      email: "[email protected]"
    }
  ) {
    id
    firstName
    lastName
    email
  }
}

Add role to user

mutation {
  addRoleToUser(
    userId: 123
    roleId: 456
  ) {
    id
    roles {
      id
      name
    }
  }
}

Remove role from user

mutation {
  removeRoleFromUser(
    userId: 123
    roleId: 456
  ) {
    id
    roles {
      id
      name
    }
  }
}

Disable user

mutation {
  disableOrEnableUser(
    userId: 123
    disable: true
  ) {
    id
    status
  }
}

Delete user

mutation {
  deleteUser(id: 123)
}

Meter mutations

Add meter

mutation {
  addMeter(
    input: {
      name: "Temperature sensor"
      assetClassId: 123
      unitId: 456
      evaluationType: NUMERIC
      position: { x: 0, y: 0, z: 0 }
    }
  ) {
    id
    name
    evaluationType
  }
}

Update meter

mutation {
  updateMeter(
    id: 123
    input: {
      name: "Updated meter name"
    }
  ) {
    id
    name
  }
}

Update meter position

mutation {
  updateMeterPosition(
    id: 123
    position: { x: 1.0, y: 2.0, z: 3.0 }
    rotation: { x: 0, y: 0, z: 0 }
  ) {
    id
    position
    rotation
  }
}

Delete meter

mutation {
  deleteMeter(id: 123)
}

Measurement mutations

Add measurement

mutation {
  addMeasurement(
    input: {
      meterId: 123
      value: "75.5"
      timestamp: "2025-01-15T10:30:00Z"
      deviceId: 456
    }
  ) {
    id
    value
    timestamp
  }
}

Add multiple measurements

mutation {
  addMultipleCustomMeasurements(
    input: [
      {
        meterId: 123
        value: "75.5"
        timestamp: "2025-01-15T10:30:00Z"
      },
      {
        meterId: 124
        value: "80.2"
        timestamp: "2025-01-15T10:30:00Z"
      }
    ]
  ) {
    id
    value
  }
}

Update measurement

mutation {
  updateMeasurement(
    id: 123
    input: {
      value: "76.0"
    }
  ) {
    id
    value
  }
}

Delete measurement

mutation {
  deleteMeasurement(id: 123)
}

Organization mutations

Add organization

mutation {
  addOrg(
    input: {
      name: "Engineering Team"
      parentOrgId: 123
    }
  ) {
    id
    name
    level
  }
}

Update organization

mutation {
  updateOrg(
    id: 123
    input: {
      name: "Updated org name"
    }
  ) {
    id
    name
  }
}

Assign users to organization

mutation {
  assignUsersToOrg(
    orgId: 123
    userIds: [456, 789]
  ) {
    id
    users {
      id
      firstName
      lastName
    }
  }
}

Allocate licenses to organization

mutation {
  allocateLicenses(
    input: {
      orgId: 123
      licenses: {
        full: 10
        viewer: 5
      }
    }
  ) {
    id
    allocatedLicenses {
      full
      viewer
    }
  }
}

Fault mutations

Add fault

mutation {
  addFault(
    input: {
      description: "Leak detected"
      assetId: 123
      severity: HIGH
    }
  ) {
    id
    description
    status
  }
}

Update fault

mutation {
  updateFault(
    id: 123
    input: {
      description: "Updated description"
      severity: MEDIUM
    }
  ) {
    id
    description
  }
}

Resolve fault

mutation {
  resolveFault(
    id: 123
    resolution: "Repaired and tested"
  ) {
    id
    status
    resolvedAt
  }
}

Reopen fault

mutation {
  reopenFault(id: 123) {
    id
    status
  }
}

Message and chat mutations

Send message

mutation {
  sendMessage(
    input: {
      chatId: 123
      content: "Message content"
    }
  ) {
    id
    content
    createdAt
  }
}

Add group chat

mutation {
  addGroupChat(
    input: {
      name: "Project team"
      userIds: [123, 456, 789]
    }
  ) {
    id
    name
    participants {
      id
      firstName
    }
  }
}

Read messages

mutation {
  readMessages(
    chatId: 123
    messageIds: [456, 789]
  )
}

File mutations

Add file

mutation {
  addFileId(
    input: {
      fileName: "document.pdf"
      contentType: "application/pdf"
      size: 1024000
    }
  ) {
    id
    fileName
    url
  }
}

Delete file

mutation {
  deleteFileId(id: 123)
}

Personal profile mutations

Add favorite entity

mutation {
  addFavoriteEntity(
    entityType: ASSET
    entityId: 123
  )
}

Remove favorite entity

mutation {
  removeFavoriteEntity(
    entityType: ASSET
    entityId: 123
  )
}

Authentication mutations

Sign in

mutation {
  signIn(
    input: {
      email: "[email protected]"
      password: "password"
    }
  ) {
    token
    user {
      id
      email
      firstName
      lastName
    }
  }
}

Sign up

mutation {
  signUp(
    input: {
      email: "[email protected]"
      password: "password"
      firstName: "John"
      lastName: "Doe"
    }
  ) {
    token
    user {
      id
      email
    }
  }
}

Next steps