GraphQL mutations - Taqtile Documentation

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

Bulk asset operations

Bulk mutations act on multiple assets in a single request. Each returns a succeeded and failed list of asset IDs. moveAssets also returns conflicts describing per-asset issues you need to resolve, such as users or asset classes that must first be assigned to the target org.

Archive assets

mutation {
  archiveAssets(
    ids: [123, 456, 789]
    force: false
    orgId: [10]
    allAvailableOrgs: [10, 11]
  ) {
    succeeded
    failed
  }
}

Argument	Type	Required	Description
`ids`	`[Int!]!`	Yes	Asset IDs to archive.
`force`	`Boolean`	No	Archive even when assets have open jobs.
`orgId`	`[Int]`	No	Restrict the operation to the specified orgs.
`allAvailableOrgs`	`[Int]`	No	Orgs the caller currently has access to.

Unarchive assets

mutation {
  unarchiveAssets(
    ids: [123, 456]
    orgId: [10]
    allAvailableOrgs: [10, 11]
  ) {
    succeeded
    failed
  }
}

Delete assets

mutation {
  deleteAssets(
    ids: [123, 456]
    force: false
    orgId: [10]
    allAvailableOrgs: [10, 11]
  ) {
    succeeded
    failed
  }
}

Pass force: true to delete assets that still have associated open work.

Move assets

mutation {
  moveAssets(
    ids: [123, 456]
    orgId: 20
    force: false
    usersWillBeAssignedToTheOrg: [789]
  ) {
    succeeded
    failed
    conflicts {
      id
      usersHaveToBeAssignedToTheOrg
      assetClassesNeedAssignToOrgs
      orgsForAssignAC
    }
  }
}

Argument	Type	Required	Description
`ids`	`[Int!]!`	Yes	Asset IDs to move.
`orgId`	`Int!`	Yes	Destination org ID.
`force`	`Boolean`	No	Move even when there are pending assignment conflicts.
`usersWillBeAssignedToTheOrg`	`[Int]`	No	Users to assign to the destination org before moving.

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: "john.doe@example.com"
    }
  ) {
    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)
}

Delete Maker user

Deletes a user that exists only in Manifest Maker.

mutation {
  deleteMakerUser(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
    }
  }
}

Invite users to organization

Send invitations to one or more users for a specific org. Each invite must include the target email and the role to assign on acceptance.

mutation {
  inviteUsersToOrg(
    orgId: 123
    invites: [
      { email: "jane@example.com", role: ADMIN }
      { email: "joe@example.com", role: MEMBER }
    ]
  ) {
    message
  }
}

Accept organization invite

Accept an invite using the token from the invitation email. userId is optional and used when accepting on behalf of an existing user.

mutation {
  acceptOrgInvite(token: "INVITE_TOKEN", userId: 456) {
    message
    org {
      id
      name
    }
  }
}

Cancel organization invite

mutation {
  cancelOrgInvite(inviteId: 123)
}

Resend organization invite

mutation {
  resendOrgInvite(inviteId: 123)
}

Update user role in organization

mutation {
  updateUserRoleInOrg(
    orgId: 123
    userId: 456
    role: ADMIN
  ) {
    id
  }
}

Remove user from team

mutation {
  removeUserFromTeam(orgId: 123, userId: 456)
}

Leave team

Removes you from the specified org team.

mutation {
  leaveTeam(orgId: 123)
}

Delete team organization

Permanently delete a team-type org.

mutation {
  deleteTeamOrg(orgId: 123)
}

Folder mutations

Folders organize templates inside an organization. Every folder mutation requires orgId and is scoped to orgs you have access to.

Create folder

mutation {
  createFolder(
    data: {
      name: "Inspections"
      parentId: 12
      orgId: 123
    }
  ) {
    id
    name
    parentId
  }
}

Argument	Type	Required	Description
`data.name`	`String`	Yes	Folder name.
`data.parentId`	`Int`	No	Parent folder ID. Omit or pass `null` to create at the root.
`data.orgId`	`Int`	Yes	Organization that owns the folder.

Update folder

mutation {
  updateFolder(
    id: 45
    data: {
      name: "Renamed folder"
      parentId: 12
      orgId: 123
    }
  ) {
    id
    name
  }
}

Delete folder

mutation {
  deleteFolder(id: 45, orgId: 123)
}

Returns true on success.

Move folder

mutation {
  moveFolder(
    folderId: 45
    newParentId: 12
    orgId: 123
  ) {
    id
    parentId
  }
}

Pass newParentId: null to move the folder to the root.

Move template into folder

mutation {
  moveTemplate(
    templateId: 789
    targetFolderId: 45
    orgId: 123
  )
}

Pass targetFolderId: null to move the template out of any folder.

Move multiple templates

mutation {
  moveTemplates(
    templateIds: [789, 790, 791]
    targetFolderId: 45
    orgId: 123
  )
}

Get folders with template counts

Returns paginated folders along with template counts for the parent folder context.

mutation {
  getFoldersWithInfo(
    parentId: 12
    orgId: 123
    itemsPerPage: 20
    pageNumber: 1
  ) {
    folders {
      id
      name
      templatesCount
    }
    totalCount
  }
}

LiveKit (Manifest Connect) mutations

Create LiveKit token

Creates or joins a LiveKit room for a chat and returns an access token plus the LiveKit WebSocket URL. You must be a participant of the chat.

mutation {
  createLiveKitToken(chatId: 123) {
    token
    wsUrl
  }
}

End LiveKit call

Ends the call and deletes the LiveKit room for a chat. You must be a participant.

mutation {
  endLiveKitCall(chatId: 123)
}

Returns true on success.

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

mutation {
  signIn(
    input: {
      email: "user@example.com"
      password: "password"
    }
  ) {
    token
    user {
      id
      email
      firstName
      lastName
    }
  }
}

mutation {
  signUp(
    input: {
      email: "user@example.com"
      password: "password"
      firstName: "John"
      lastName: "Doe"
    }
  ) {
    token
    user {
      id
      email
    }
  }
}

Next steps

Queries - Retrieve data with queries
Overview - GraphQL API overview

​Asset mutations

​Add asset

​Update asset

​Archive asset

​Delete asset

​Bulk asset operations

​Archive assets

​Unarchive assets

​Delete assets

​Move assets

​Asset class mutations

​Add asset class

​Update asset class

​Add model to asset class

​Delete asset class

​Job mutations

​Add job

​Update job

​Start job

​Complete job

​Assign user to job

​Add note to job

​Cancel job

​Template mutations

​Add template

​Update template

​Copy template

​Delete template

​Template version mutations

​Create template version

​Update template version

​Edit version state

​Location mutations

​Add location

​Update location

​Delete location

​User mutations

​Update user

​Add role to user

​Remove role from user

​Disable user

​Delete user

​Delete Maker user

​Meter mutations

​Add meter

​Update meter

​Update meter position

​Delete meter

​Measurement mutations

​Add measurement

​Add multiple measurements

​Update measurement

​Delete measurement

​Organization mutations

​Add organization

​Update organization

​Assign users to organization

​Allocate licenses to organization

​Invite users to organization

​Accept organization invite

​Cancel organization invite

​Resend organization invite

​Update user role in organization

​Remove user from team

​Leave team

​Delete team organization

​Folder mutations

​Create folder

​Update folder

​Delete folder

​Move folder

​Move template into folder

​Move multiple templates

​Get folders with template counts

​LiveKit (Manifest Connect) mutations

​Create LiveKit token

​End LiveKit call

​Fault mutations

​Add fault

​Update fault