@spec add_customer_owned_item(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Assign an inventory item.

GraphQL: mutation { addCustomerOwnedItem }

Arguments

• input — AddCustomerOwnedItemInput! — The input required to add a customer owned item.

@spec add_impacted_accounts_to_incident(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Add impacted accounts to an incident.

GraphQL: mutation { addImpactedAccountsToIncident }

Arguments

• input — AddImpactedAccountsToIncidentInput! — The input required to add impacted accounts to an incident.

@spec add_impacted_accounts_to_incident_from_geofence(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Add impacted accounts to an incident from a geofence.

GraphQL: mutation { addImpactedAccountsToIncidentFromGeofence }

Arguments

• input — AddImpactedAccountsToIncidentFromGeofenceInput! — The input required to add impacted accounts to an incident from a geofence.

@spec add_impacted_accounts_to_incident_from_network_sites(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) :: {:ok, term()} | {:error, Gaiia.Error.t()}

Add impacted accounts to an incident from network sites.

GraphQL: mutation { addImpactedAccountsToIncidentFromNetworkSites }

Arguments

• input — AddImpactedAccountsToIncidentFromNetworkSitesInput! — The input required to add impacted accounts to an incident from network sites.

@spec add_impacted_accounts_to_incident_from_properties(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Add impacted accounts to an incident from properties.

GraphQL: mutation { addImpactedAccountsToIncidentFromProperties }

Arguments

• input — AddImpactedAccountsToIncidentFromPropertiesInput! — The input required to add impacted accounts to an incident from properties.

@spec add_inventory_item_linked_devices(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Add new linked devices to an inventory item.

GraphQL: mutation { addInventoryItemLinkedDevices }

Arguments

• input — AddInventoryItemLinkedDevicesInput! — The addInventoryItemLinkedDevices mutation's input.

@spec add_ip_block_to_inventory_item(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Add an IP block to an inventory item.

GraphQL: mutation { addIpBlockToInventoryItem }

Arguments

• input — AddIpBlockToInventoryItemInput! — The addIpBlockToInventoryItem mutation's input.

@spec add_ip_blocks_to_network_site(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Add IP blocks to a network site.

GraphQL: mutation { addIpBlocksToNetworkSite }

Arguments

• input — AddIpBlocksToNetworkSiteInput! — The addIpBlocksToNetworkSite mutation's input.

@spec add_procedure_to_incident(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Add a given procedure to an incident.

GraphQL: mutation { addProcedureToIncident }

Arguments

• input — AddProcedureToIncidentInput! — The input required to add a procedure to an incident.

@spec archive_address(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive an address.

GraphQL: mutation { archiveAddress }

Arguments

• addressId — GlobalID! — The address's unique ID.

@spec archive_bundle(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a bundle.

GraphQL: mutation { archiveBundle }

Arguments

• input — ArchiveBundleInput! — The archiveBundle mutation's input.

@spec archive_coverage_areas(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive multiple coverage areas.

GraphQL: mutation { archiveCoverageAreas }

Arguments

• coverageAreaIds — [GlobalID!]! — The coverage areas' unique IDs.

@spec archive_custom_object(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a custom object definition.

GraphQL: mutation { archiveCustomObject }

Arguments

• id — GlobalID! — The definition's unique identifier.

@spec archive_custom_object_field(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a custom object field definition.

GraphQL: mutation { archiveCustomObjectField }

Arguments

• id — GlobalID! — The field definition's unique identifier.

@spec archive_custom_object_record(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a custom object record.

GraphQL: mutation { archiveCustomObjectRecord }

Arguments

• id — GlobalID! — The record's unique identifier.

@spec archive_inventory_roles(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive existing inventory roles.

GraphQL: mutation { archiveInventoryRoles }

Arguments

• input — ArchiveInventoryRolesInput! — The archiveInventoryRoles mutation's input.

@spec archive_network_sites(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive one or more network sites.

GraphQL: mutation { archiveNetworkSites }

Arguments

• ids — [GlobalID!]! — The network sites unique identifiers.

@spec archive_property(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a property.

GraphQL: mutation { archiveProperty }

Arguments

• id — GlobalID! — The property's unique ID.

@spec archive_schedule_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive (soft-delete) an existing schedule template.

GraphQL: mutation { archiveScheduleTemplate }

Arguments

• input — ArchiveScheduleTemplateInput! — The input required to archive a schedule template.

@spec archive_technician(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive (soft-delete) an existing technician.

GraphQL: mutation { archiveTechnician }

Arguments

• input — ArchiveTechnicianInput! — The input required to archive a technician.

@spec archive_technician_team(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive (soft-delete) an existing technician team.

GraphQL: mutation { archiveTechnicianTeam }

Arguments

• input — ArchiveTechnicianTeamInput! — The input required to archive a technician team.

@spec archive_ticket(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a ticket.

GraphQL: mutation { archiveTicket }

Arguments

• id — GlobalID! — The ticket's unique ID.

@spec archive_ticket_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a ticket template.

GraphQL: mutation { archiveTicketTemplate }

Arguments

• id — GlobalID! — The ticket template's unique ID.

@spec archive_unit(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a unit.

GraphQL: mutation { archiveUnit }

Arguments

• id — GlobalID! — The unit's unique ID.

@spec archive_work_order(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive (soft-delete) an existing work order.

GraphQL: mutation { archiveWorkOrder }

Arguments

• input — ArchiveWorkOrderInput! — The input required to archive a work order.

@spec archive_work_order_custom_status(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive a work order custom status by unique ID.

GraphQL: mutation { archiveWorkOrderCustomStatus }

Arguments

• input — ArchiveWorkOrderCustomStatusInput! — The input required to archive a work order custom status.

@spec archive_work_type(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Archive (soft-delete) an existing work type.

GraphQL: mutation { archiveWorkType }

Arguments

• input — ArchiveWorkTypeInput! — The input required to archive a work type.

@spec assign_billing_subscriptions(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Assign billing subscriptions.

GraphQL: mutation { assignBillingSubscriptions }

Arguments

• input — AssignBillingSubscriptionsMutationInput! — The input required to assign billing subscriptions.

@spec assign_inventory_item(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Assign an inventory item.

GraphQL: mutation { assignInventoryItem }

Arguments

• input — AssignInventoryItemInput! — The input required to assign an inventory item.

@spec assign_secondary_technicians_to_work_order(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Assign secondary technicians to a work order which is already assigned to a primary technician.

GraphQL: mutation { assignSecondaryTechniciansToWorkOrder }

Arguments

• input — AssignSecondaryTechniciansToWorkOrderInput! — The input required to assign secondary technicians to a work order.

@spec assign_technician_to_work_order(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Assign a primary technician to a work order.

GraphQL: mutation { assignTechnicianToWorkOrder }

Arguments

• input — AssignTechnicianToWorkOrderInput! — The input required to assign a technician to a work order.

@spec assign_upstream_device_to_inventory_item(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Assign an upstream device to an inventory item.

GraphQL: mutation { assignUpstreamDeviceToInventoryItem }

Arguments

• input — AssignUpstreamDeviceToInventoryItemInput! — The assignUpstreamDeviceToInventoryItem mutation's input.

@spec auto_assign_work_order(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Auto-assign a work order.

GraphQL: mutation { autoAssignWorkOrder }

Arguments

• input — AutoAssignWorkOrderInput! — The input required to auto-assign a work order.

@spec cancel_and_duplicate_work_order_with_work_type(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Cancel and duplicate a work order with a new work type.

GraphQL: mutation { cancelAndDuplicateWorkOrderWithWorkType }

Arguments

• input — CancelAndDuplicateWorkOrderWithWorkTypeInput! — The input required to cancel and duplicate a work order with a new work type.

@spec cancel_workflow_execution(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Cancel the workflow execution.

GraphQL: mutation { cancelWorkflowExecution }

Arguments

• input — CancelWorkflowExecutionInput! — The input required to cancel a workflow execution.

@spec clear_inventory_item_linked_devices(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Clear all linked devices from an inventory item.

GraphQL: mutation { clearInventoryItemLinkedDevices }

Arguments

• input — ClearInventoryItemLinkedDevicesInput! — The clearInventoryItemLinkedDevices mutation's input.

@spec close_ticket(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Close a ticket.

GraphQL: mutation { closeTicket }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — CloseTicketInput! — The input required to close a ticket.

@spec convert_ticket_to_external(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Convert an internal ticket to external by adding public information.

GraphQL: mutation { convertTicketToExternal }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — ConvertTicketToExternalInput! — The input required to convert an internal ticket to external.

@spec create_account(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new account.

GraphQL: mutation { createAccount }

Arguments

• input — CreateAccountInput! — The input required to create an account.

@spec create_account_contact(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a contact.

GraphQL: mutation { createAccountContact }

Arguments

• accountId — GlobalID! — The account's unique ID.
• input — CreateAccountContactInput! — The input required to create a contact.

@spec create_account_service_cancellation_reason(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new account service cancellation reason.

GraphQL: mutation { createAccountServiceCancellationReason }

Arguments

• input — CreateAccountServiceCancellationReasonInput! — The input required to create an account service cancellation reason.

@spec create_address(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create an address.

GraphQL: mutation { createAddress }

Arguments

• input — CreateGeoAddressInput! — The address's input.

@spec create_addresses(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create addresses.

GraphQL: mutation { createAddresses }

Arguments

• input — CreateAddressesInput! — The addresses input.

@spec create_api_key(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new API key.

GraphQL: mutation { createApiKey }

Arguments

• input — CreateApiKeyInput! — The input required to create an API key.

@spec create_bundle(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a bundle.

GraphQL: mutation { createBundle }

Arguments

• input — CreateBundleInput! — The createBundle mutation's input.

@spec create_contract(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new contract. This mutation should be used in combination with createContractUploadUrl. See the Files section of the documentation for more information.

GraphQL: mutation { createContract }

Arguments

• input — CreateContractInput! — The input required to create a contract.

@spec create_contract_upload_url(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Creates a contract upload URL.

GraphQL: mutation { createContractUploadUrl }

Arguments

• input — CreateContractUploadUrlInput! — The input to create a contract upload url.

@spec create_coverage_area(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Creates a new coverage area.

GraphQL: mutation { createCoverageArea }

Arguments

• input — CreateCoverageAreaInput! — The coverage area's input.

@spec create_custom_object(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new custom object definition.

GraphQL: mutation { createCustomObject }

Arguments

• input — CreateCustomObjectInput! — The mutation input.

@spec create_custom_object_field(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new field definition on a custom object.

GraphQL: mutation { createCustomObjectField }

Arguments

• input — CreateCustomObjectFieldInput! — The mutation input.

@spec create_custom_object_record(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new custom object record.

GraphQL: mutation { createCustomObjectRecord }

Arguments

• input — CreateCustomObjectRecordInput! — The mutation input.

@spec create_custom_object_record_draft(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new draft custom object record. Required fields are not enforced until publish.

GraphQL: mutation { createCustomObjectRecordDraft }

Arguments

• input — CreateCustomObjectRecordDraftInput! — The mutation input.

@spec create_debits(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create debits.

GraphQL: mutation { createDebits }

Arguments

• input — CreateDebitsInput! — The input required to create debits.

@spec create_document(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new document. This mutation should be used in combination with createDocumentUploadUrl. See the Files section of the documentation for more information.

GraphQL: mutation { createDocument }

Arguments

• input — CreateDocumentInput! — The input required to create a document.

@spec create_document_upload_url(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Creates a document upload URL.

GraphQL: mutation { createDocumentUploadUrl }

Arguments

• input — CreateDocumentUploadUrlInput! — The input to create a document upload URL.

@spec create_external_ticket(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new external ticket.

GraphQL: mutation { createExternalTicket }

Arguments

• input — CreateExternalTicketInput! — The input required to create an external ticket.

@spec create_external_ticket_from_template(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create an external ticket from a ticket template, optionally overriding any of the template's defaults.

GraphQL: mutation { createExternalTicketFromTemplate }

Arguments

• input — CreateExternalTicketFromTemplateInput! — The input required to create an external ticket from a template.

@spec create_geofence(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a geofence.

GraphQL: mutation { createGeofence }

Arguments

• input — CreateGeofenceInput! — The geofence's input.

@spec create_incident(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new incident.

GraphQL: mutation { createIncident }

Arguments

• input — CreateIncidentInput! — The input required to create an incident.

@spec create_internal_ticket(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new internal ticket.

GraphQL: mutation { createInternalTicket }

Arguments

• input — CreateInternalTicketInput! — The input required to create an internal ticket.

@spec create_internal_ticket_from_template(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create an internal ticket from a ticket template, optionally overriding any of the template's defaults.

GraphQL: mutation { createInternalTicketFromTemplate }

Arguments

• input — CreateInternalTicketFromTemplateInput! — The input required to create an internal ticket from a template.

@spec create_inventory_items(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create new inventory items.

GraphQL: mutation { createInventoryItems }

Arguments

• input — CreateInventoryItemsInput! — The input required to create new inventory items.

@spec create_inventory_location_address(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create an inventory location address.

GraphQL: mutation { createInventoryLocationAddress }

Arguments

• input — CreateInventoryLocationAddressInput! — The input required to create an inventory location address.

@spec create_inventory_model(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Mutation to create an inventory model.

GraphQL: mutation { createInventoryModel }

Arguments

• input — CreateInventoryModelInput! — The input required to create an inventory model.

@spec create_inventory_model_category(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new inventory model category.

GraphQL: mutation { createInventoryModelCategory }

Arguments

• input — CreateInventoryModelCategoryInput! — The input required to create a new inventory model category.

@spec create_inventory_role(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new inventory role.

GraphQL: mutation { createInventoryRole }

Arguments

• input — CreateInventoryRoleInput! — The createInventoryRole mutation's input.

@spec create_invoice(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Generate an invoice on an account. All uninvoiced transactions will be included.

GraphQL: mutation { createInvoice }

Arguments

• input — CreateInvoiceInput! — The input required to create an invoice.

@spec create_manufacturer(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new manufacturer.

GraphQL: mutation { createManufacturer }

Arguments

• input — CreateManufacturerInput! — The createManufacturer mutation's input.

@spec create_network_site(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a network site.

GraphQL: mutation { createNetworkSite }

Arguments

• input — CreateNetworkSiteInput! — The input required to create a network site.

@spec create_note(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new note.

GraphQL: mutation { createNote }

Arguments

• input — CreateNoteInput! — The input required to create a note.

@spec create_payment(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a payment.

GraphQL: mutation { createPayment }

Arguments

• input — CreatePaymentInput! — The input required to create a payment.

@spec create_payment_method(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a payment method for a billable entity. The payment method can be used for payments and optionally for automatic payments.

GraphQL: mutation { createPaymentMethod }

Arguments

• input — CreatePaymentMethodInput! — The input required to create a payment method.

@spec create_product(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a product.

GraphQL: mutation { createProduct }

Arguments

• input — CreateProductInput! — The createProduct mutation's input.

@spec create_product_category(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a product category.

GraphQL: mutation { createProductCategory }

Arguments

• input — CreateProductCategoryInput! — The createProductCategory mutation's input.

@spec create_product_version(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new product version.

GraphQL: mutation { createProductVersion }

Arguments

• input — CreateProductVersionInput! — The createProductVersion mutation's input.

@spec create_project(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new project.

GraphQL: mutation { createProject }

Arguments

• input — CreateProjectInput! — The input required to create a project.

@spec create_property(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a property.

GraphQL: mutation { createProperty }

Arguments

• input — CreatePropertyInput! — The input required to create a property.

@spec create_property_contact(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a property's contact.

GraphQL: mutation { createPropertyContact }

Arguments

• id — GlobalID! — The property's unique ID.
• input — CreatePropertyContactInput! — The input required to create a property's contact.

@spec create_property_group(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a property group.

GraphQL: mutation { createPropertyGroup }

Arguments

• input — CreatePropertyGroupInput! — The input required to create a property group.

@spec create_property_units(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create units.

GraphQL: mutation { createPropertyUnits }

Arguments

• propertyId — GlobalID! — The property's unique ID.
• input — CreatePropertyUnitsInput! — The input required to a property's units.

@spec create_role(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new role.

GraphQL: mutation { createRole }

Arguments

• input — CreateRoleInput! — The input required to create a role.

@spec create_schedule_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new schedule template.

GraphQL: mutation { createScheduleTemplate }

Arguments

• input — CreateScheduleTemplateInput! — The input required to create a schedule template.

@spec create_tag_definition(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a tag definition.

GraphQL: mutation { createTagDefinition }

Arguments

• input — CreateTagDefinitionInput! — The input required to create a tag definition.

@spec create_tag_value(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a value for a tag.

GraphQL: mutation { createTagValue }

Arguments

• tagDefinitionId — GlobalID! — The tag definition's unique ID.
• input — CreateTagValueInput! — The input required to create a tag value.

@spec create_technician(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new technician.

GraphQL: mutation { createTechnician }

Arguments

• input — CreateTechnicianInput! — The input required to create a technician.

@spec create_technician_team(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new technician team.

GraphQL: mutation { createTechnicianTeam }

Arguments

• input — CreateTechnicianTeamInput! — The input required to create a technician team.

@spec create_ticket_comment(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new ticket comment.

GraphQL: mutation { createTicketComment }

Arguments

• input — CreateTicketCommentInput! — The input required to create a ticket comment.

@spec create_ticket_comment_attachment_upload_url(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a ticket comment attachment upload URL. This mutation should be used in combination with createTicketCommentAttachments. See the Files section of the documentation for more information.

GraphQL: mutation { createTicketCommentAttachmentUploadUrl }

Arguments

• input — CreateTicketCommentAttachmentUploadUrlInput! — The input required to create a ticket comment attachment upload URL.

@spec create_ticket_comment_attachments(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create ticket comment attachments. This mutation should be used after uploading files using URLs from createTicketCommentAttachmentUploadUrl. See the Files section of the documentation for more information.

GraphQL: mutation { createTicketCommentAttachments }

Arguments

• input — CreateTicketCommentAttachmentsInput! — The input required to create ticket comment attachments.

@spec create_ticket_from_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a ticket from a ticket template.

GraphQL: mutation { createTicketFromTemplate }

Arguments

• templateId — GlobalID! — The ticket template's ID.

@spec create_ticket_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a ticket template.

GraphQL: mutation { createTicketTemplate }

Arguments

• input — CreateTicketTemplateInput! — The ticket template's input.

@spec create_ticket_worklog(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new ticket worklog.

GraphQL: mutation { createTicketWorklog }

Arguments

• input — CreateTicketWorklogInput! — The input required to create a ticket worklog.

@spec create_time_blocker(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new time blocker.

GraphQL: mutation { createTimeBlocker }

Arguments

• input — CreateTimeBlockerInput! — The createTimeBlocker mutation's input.

@spec create_user(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new user.

GraphQL: mutation { createUser }

Arguments

• input — CreateUserInput! — The input required to create a user.

@spec create_webhook(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new webhook.

GraphQL: mutation { createWebhook }

Arguments

• input — CreateWebhookInput! — The input required to create a webhook.

@spec create_work_order(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new work order.

GraphQL: mutation { createWorkOrder }

Arguments

• input — CreateWorkOrderInput! — The input required to create a work order.

@spec create_work_order_custom_status(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new work order custom status.

GraphQL: mutation { createWorkOrderCustomStatus }

Arguments

• input — CreateWorkOrderCustomStatusInput! — The input required to create a work order custom status.

@spec create_work_order_note(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new work order note.

GraphQL: mutation { createWorkOrderNote }

Arguments

• input — CreateWorkOrderNoteInput! — The input required to create a work order note.

@spec create_work_type(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new work type.

GraphQL: mutation { createWorkType }

Arguments

• input — CreateWorkTypeInput! — The input required to create a work type.

@spec create_workflow_secret(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new workflow secret.

GraphQL: mutation { createWorkflowSecret }

Arguments

• input — CreateWorkflowSecretInput! — The input required to create a workflow secret.

@spec create_workflow_variable(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Create a new workflow variable.

GraphQL: mutation { createWorkflowVariable }

Arguments

• input — CreateWorkflowVariableInput! — The input required to create a workflow variable.

@spec deactivate_user(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Deactivate a user.

GraphQL: mutation { deactivateUser }

Arguments

• id — GlobalID! — The user's unique ID.

@spec delete_incident_procedure(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete an incident procedure.

GraphQL: mutation { deleteIncidentProcedure }

Arguments

• input — DeleteIncidentProcedureInput! — The input required to delete an incident procedure.

@spec delete_note(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete a note.

GraphQL: mutation { deleteNote }

Arguments

• noteId — GlobalID! — The notes's unique ID.

@spec delete_payment_method(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete a payment method. The payment method will be archived (soft delete) in the billing system, and removal from the payment processor will be attempted. The payment method record remains in the database, marked as archived, and will not appear in queries.

GraphQL: mutation { deletePaymentMethod }

Arguments

• input — DeletePaymentMethodInput! — The input required to delete a payment method.

@spec delete_role(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete a role.

GraphQL: mutation { deleteRole }

Arguments

• id — GlobalID! — The role's unique ID.

@spec delete_ticket_comment(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete a ticket comment.

GraphQL: mutation { deleteTicketComment }

Arguments

• id — GlobalID! — The ticket comment's unique ID.

@spec delete_time_blocker(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete a time blocker by unique ID.

GraphQL: mutation { deleteTimeBlocker }

Arguments

• input — DeleteTimeBlockerInput! — The input required to delete a time blocker.

@spec delete_unit(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete a unit.

GraphQL: mutation { deleteUnit }

Arguments

• id — GlobalID! — The unit's unique ID.

@spec delete_webhook(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete a webhook by unique ID.

GraphQL: mutation { deleteWebhook }

Arguments

• input — DeleteWebhookInput! — The input required to delete a webhook.

@spec delete_workflow_secret(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete an existing workflow secret.

GraphQL: mutation { deleteWorkflowSecret }

Arguments

• id — GlobalID! — The unique identifier of the secret to delete.

@spec delete_workflow_variable(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Delete an existing workflow variable.

GraphQL: mutation { deleteWorkflowVariable }

Arguments

• id — GlobalID! — The unique identifier of the variable to delete.

@spec end_technician_shift(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

End a technician's shift.

GraphQL: mutation { endTechnicianShift }

Arguments

• input — EndTechnicianShiftInput! — The input required to end a technician's shift.

@spec initiate_pin_verification(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Initiate a PIN verification session for an entity.

GraphQL: mutation { initiatePinVerification }

Arguments

• entityId — GlobalID! — The entity to verify.
• input — InitiatePinVerificationInput! — The input required to initiate a PIN verification session.

@spec integration_none(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

GraphQL mutation integrationNone.

GraphQL: mutation { integrationNone }

Takes no arguments.

@spec merge_tickets(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Merge a child ticket into a parent ticket. The child ticket will be closed and archived.

GraphQL: mutation { mergeTickets }

Arguments

• input — MergeTicketsInput! — The input required to merge tickets.

@spec publish_custom_object_record_draft(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Publish a draft custom object record, promoting it to a real record. Enforces all required fields and uniqueness constraints.

GraphQL: mutation { publishCustomObjectRecordDraft }

Arguments

• id — GlobalID — The draft record's unique identifier.
• input — PublishCustomObjectRecordDraftInput! — The mutation input.

@spec reactivate_user(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Reactivate a user.

GraphQL: mutation { reactivateUser }

Arguments

• id — GlobalID! — The user's unique ID.

@spec remove_impacted_accounts_from_incident(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Remove impacted accounts from an incident.

GraphQL: mutation { removeImpactedAccountsFromIncident }

Arguments

• input — RemoveImpactedAccountsFromIncidentInput! — The input required to remove impacted accounts from an incident.

@spec remove_inventory_item_linked_devices(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Remove linked devices from an inventory item.

GraphQL: mutation { removeInventoryItemLinkedDevices }

Arguments

• input — RemoveInventoryItemLinkedDevicesInput! — The removeInventoryItemLinkedDevices mutation's input.

@spec remove_ip_block_from_inventory_item(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Remove an IP block from an inventory item.

GraphQL: mutation { removeIpBlockFromInventoryItem }

Arguments

• input — RemoveIpBlockFromInventoryItemInput! — The removeIpBlockFromInventoryItem mutation's input.

@spec remove_ip_blocks_from_network_site(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Remove IP blocks from a network site.

GraphQL: mutation { removeIpBlocksFromNetworkSite }

Arguments

• input — RemoveIpBlocksFromNetworkSiteInput! — The removeIpBlocksFromNetworkSite mutation's input.

@spec remove_primary_from_product_version(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Remove the primary flag from a product version.

GraphQL: mutation { removePrimaryFromProductVersion }

Arguments

• id — GlobalID! — The product version's ID.

@spec restrict_entity_payment_method_type(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Restrict a payment method type for a billable entity. No new payment methods of that type can be created. For ACCOUNT scope, existing payment methods of that type are also archived; for BILLING_SETTINGS scope existing payment methods are left in place but can no longer be used for payments.

GraphQL: mutation { restrictEntityPaymentMethodType }

Arguments

• input — RestrictEntityPaymentMethodTypeInput! — The input required to restrict a payment method type.

@spec retry_workflow_execution(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Retry the workflow execution.

GraphQL: mutation { retryWorkflowExecution }

Arguments

• input — RetryWorkflowExecutionInput! — The input required to retry a workflow execution.

@spec revoke_api_key(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Revoke an API key.

GraphQL: mutation { revokeApiKey }

Arguments

• id — GlobalID! — The API key's unique ID.

@spec send_communication(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Send a communication to an entity using a template.

GraphQL: mutation { sendCommunication }

Arguments

• input — SendCommunicationInput! — The input required to send a communication.

@spec set_primary_product_version(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Set a product version as primary.

GraphQL: mutation { setPrimaryProductVersion }

Arguments

• id — GlobalID! — The product version's ID.
• input — SetPrimaryProductVersionInput! — The setPrimaryProductVersion mutation's input.

@spec skip_node_execution(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Skip a failed node execution.

GraphQL: mutation { skipNodeExecution }

Arguments

• input — SkipNodeExecutionInput! — The input required to skip a node execution.

@spec start_product_availability_job(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Start an asynchronous job to check available products at a given location. Requires a gaiia publishable key in the request headers.

GraphQL: mutation { startProductAvailabilityJob }

Arguments

• input — StartProductAvailabilityJobInput! — The input required to create a product availability job.

@spec start_technician_shift(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Start a technician's shift.

GraphQL: mutation { startTechnicianShift }

Arguments

• input — StartTechnicianShiftInput! — The input required to start a technician's shift.

@spec start_work_order_auto_assign(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Send a work order to the auto-assign queue for async processing.

GraphQL: mutation { startWorkOrderAutoAssign }

Arguments

• input — StartWorkOrderAutoAssignInput! — The input required to start work order auto-assign.

@spec start_workflow_execution(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Start the workflow execution.

GraphQL: mutation { startWorkflowExecution }

Arguments

• input — StartWorkflowExecutionInput! — The input required to start a workflow execution.

@spec toggle_auto_payment(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Toggle auto payment on a payment method. Enabling auto payment on a payment method will disable it on all other payment methods for the same account.

GraphQL: mutation { toggleAutoPayment }

Arguments

• input — ToggleAutoPaymentInput! — The input required to toggle auto payment.

@spec unarchive_address(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive an address.

GraphQL: mutation { unarchiveAddress }

Arguments

• addressId — GlobalID! — The address's unique ID.

@spec unarchive_coverage_areas(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive multiple coverage areas.

GraphQL: mutation { unarchiveCoverageAreas }

Arguments

• coverageAreaIds — [GlobalID!]! — The coverage areas' unique IDs.

@spec unarchive_custom_object(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive a custom object definition.

GraphQL: mutation { unarchiveCustomObject }

Arguments

• id — GlobalID! — The definition's unique identifier.

@spec unarchive_custom_object_field(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive a custom object field definition.

GraphQL: mutation { unarchiveCustomObjectField }

Arguments

• id — GlobalID! — The field definition's unique identifier.

@spec unarchive_custom_object_record(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive a custom object record.

GraphQL: mutation { unarchiveCustomObjectRecord }

Arguments

• id — GlobalID! — The record's unique identifier.

@spec unarchive_inventory_roles(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive existing inventory roles.

GraphQL: mutation { unarchiveInventoryRoles }

Arguments

• input — UnarchiveInventoryRolesInput! — The unarchiveInventoryRoles mutation's input.

@spec unarchive_network_sites(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive one or more network sites.

GraphQL: mutation { unarchiveNetworkSites }

Arguments

• ids — [GlobalID!]! — The network sites unique identifiers.

@spec unarchive_property(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchives a property.

GraphQL: mutation { unarchiveProperty }

Arguments

• id — GlobalID! — The property's unique ID.

@spec unarchive_property_group(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchives a property group.

GraphQL: mutation { unarchivePropertyGroup }

Arguments

• id — GlobalID! — The property group's unique ID.

@spec unarchive_ticket(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive a ticket.

GraphQL: mutation { unarchiveTicket }

Arguments

• id — GlobalID! — The ticket's unique ID.

@spec unarchive_ticket_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive a ticket template.

GraphQL: mutation { unarchiveTicketTemplate }

Arguments

• id — GlobalID! — The ticket template's unique ID.

@spec unarchive_unit(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unarchive a unit.

GraphQL: mutation { unarchiveUnit }

Arguments

• id — GlobalID! — The unit's unique ID.

@spec unassign_all_technicians_from_work_order(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unassign all technicians from work order.

GraphQL: mutation { unassignAllTechniciansFromWorkOrder }

Arguments

• input — UnassignAllTechniciansFromWorkOrderInput! — The input required to unassign all technicians from a work order.

@spec unassign_customer_owned_item(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unassign a customer owned item.

GraphQL: mutation { unassignCustomerOwnedItem }

Arguments

• input — UnassignCustomerOwnedItemInput! — The unassignCustomerOwnedItem mutation's input.

@spec unassign_secondary_technicians_from_work_order(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unassigns secondary technicians from a work order.

GraphQL: mutation { unassignSecondaryTechniciansFromWorkOrder }

Arguments

• input — UnassignSecondaryTechniciansFromWorkOrderInput! — The input required to unassign secondary technicians from a work order.

@spec unassign_upstream_device_from_inventory_item(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unassign an upstream device from an inventory item.

GraphQL: mutation { unassignUpstreamDeviceFromInventoryItem }

Arguments

• input — UnassignUpstreamDeviceFromInventoryItemInput! — The unassignUpstreamDeviceFromInventoryItem mutation's input.

@spec unrestrict_entity_payment_method_type(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Unrestrict a payment method type for a billable entity. For ACCOUNT scope the failure counter is reset to zero. Previously archived payment methods remain archived — the customer must create new ones.

GraphQL: mutation { unrestrictEntityPaymentMethodType }

Arguments

• input — UnrestrictEntityPaymentMethodTypeInput! — The input required to unrestrict a payment method type.

@spec update_account(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an account.

GraphQL: mutation { updateAccount }

Arguments

• id — GlobalID! — The account's unique ID.
• input — UpdateAccountInput! — The input required to update an account.

@spec update_account_contact(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a contact.

GraphQL: mutation { updateAccountContact }

Arguments

• accountId — GlobalID! — The account's unique ID.
• id — GlobalID! — The contact's unique ID.
• input — UpdateAccountContactInput! — The input required to update a contact.

@spec update_account_custom_field_definition(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an account custom field definition.

GraphQL: mutation { updateAccountCustomFieldDefinition }

Arguments

• id — GlobalID! — The account custom field definition's unique ID.
• input — UpdateAccountCustomFieldDefinitionInput! — The input required to update an account custom field definition.

@spec update_account_mailing_address(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an account's mailing address.

GraphQL: mutation { updateAccountMailingAddress }

Arguments

• id — GlobalID! — The account's unique id.
• input — UpdateAccountMailingAddressInput! — The input required to update an account's mailing address.

@spec update_account_physical_address(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an account's physical address.

GraphQL: mutation { updateAccountPhysicalAddress }

Arguments

• id — GlobalID! — The account's unique id.
• input — UpdateAccountPhysicalAddressInput! — The input required to update an account's physical address.

@spec update_address(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an address.

GraphQL: mutation { updateAddress }

Arguments

• id — GlobalID! — The address's unique ID.
• input — UpdateGeoAddressInput! — The address's input.

@spec update_address_custom_field_definition(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an address custom field definition.

GraphQL: mutation { updateAddressCustomFieldDefinition }

Arguments

• id — GlobalID! — The custom field definition's unique ID.
• input — UpdateAddressCustomFieldDefinitionInput! — Input containing the custom field definition update details.

@spec update_address_custom_fields(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update custom fields for an address.

GraphQL: mutation { updateAddressCustomFields }

Arguments

• input — UpdateAddressCustomFieldsInput! — Input containing address ID and field updates.

@spec update_addresses(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update addresses.

GraphQL: mutation { updateAddresses }

Arguments

• input — UpdateAddressesInput! — The addresses input.

@spec update_api_key(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an API key.

GraphQL: mutation { updateApiKey }

Arguments

• id — GlobalID! — The API key's unique identifier.
• input — UpdateApiKeyInput! — The input required to update an API key.

@spec update_bundle(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a bundle.

GraphQL: mutation { updateBundle }

Arguments

• input — UpdateBundleInput! — The updateBundle mutation's input.

@spec update_contract(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a contract.

GraphQL: mutation { updateContract }

Arguments

• id — GlobalID — The contract's unique id.
• input — UpdateContractInput! — The input required to update a contract.

@spec update_coverage_area(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Updates an existing coverage area.

GraphQL: mutation { updateCoverageArea }

Arguments

• input — UpdateCoverageAreaInput! — The coverage area's input.

@spec update_custom_object(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a custom object definition.

GraphQL: mutation { updateCustomObject }

Arguments

• id — GlobalID! — The definition's unique identifier.
• input — UpdateCustomObjectInput! — The mutation input.

@spec update_custom_object_field(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a custom field definition.

GraphQL: mutation { updateCustomObjectField }

Arguments

• id — GlobalID — The field definition's unique identifier.
• input — UpdateCustomObjectFieldInput! — The mutation input.

@spec update_custom_object_record(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing custom object record.

GraphQL: mutation { updateCustomObjectRecord }

Arguments

• id — GlobalID — The record's unique identifier.
• input — UpdateCustomObjectRecordInput! — The mutation input.

@spec update_custom_object_record_draft(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing draft custom object record.

GraphQL: mutation { updateCustomObjectRecordDraft }

Arguments

• id — GlobalID! — The draft record's unique identifier.
• input — UpdateCustomObjectRecordDraftInput! — The mutation input.

@spec update_default_appointment_config(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update the default appointment configuration for the current tenant.

GraphQL: mutation { updateDefaultAppointmentConfig }

Arguments

• input — UpdateDefaultAppointmentConfigInput! — The updateDefaultAppointmentConfig mutation's input.

@spec update_delinquency_step(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a delinquency step.

GraphQL: mutation { updateDelinquencyStep }

Arguments

• input — UpdateDelinquencyStepInput! — The input required to update a delinquency step.

@spec update_entity_custom_field_definition(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an entity custom field definition.

GraphQL: mutation { updateEntityCustomFieldDefinition }

Arguments

• id — GlobalID! — The entity custom field definition's unique ID.
• input — UpdateEntityCustomFieldDefinitionInput! — The input required to update an entity custom field definition.

@spec update_entity_custom_fields(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an entity's custom fields.

GraphQL: mutation { updateEntityCustomFields }

Arguments

• entityId — GlobalID! — The entity's unique ID.
• input — UpdateEntityCustomFieldsInput! — The input required to update an entity's custom fields.

@spec update_external_ticket(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an external ticket.

GraphQL: mutation { updateExternalTicket }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — UpdateExternalTicketInput! — The input required to update an external ticket.

@spec update_incident(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an incident.

GraphQL: mutation { updateIncident }

Arguments

• input — UpdateIncidentInput! — The input required to update an incident.

@spec update_internal_ticket(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an internal ticket.

GraphQL: mutation { updateInternalTicket }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — UpdateInternalTicketInput! — The input required to update an internal ticket.

@spec update_inventory_item(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an inventory item. Only provided fields are updated; omitted fields are left unchanged.

GraphQL: mutation { updateInventoryItem }

Arguments

• inventoryItemId — GlobalID — The inventory item's ID. Optional for backwards compatibility — prefer this over the deprecated input field.
• input — UpdateInventoryItemInput! — The input required to update an inventory item.

@spec update_inventory_location_address(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an inventory location address.

GraphQL: mutation { updateInventoryLocationAddress }

Arguments

• input — UpdateInventoryLocationAddressInput! — The input required to update an inventory location address.

@spec update_inventory_role(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing inventory role.

GraphQL: mutation { updateInventoryRole }

Arguments

• input — UpdateInventoryRoleInput! — The updateInventoryRole mutation's input.

@spec update_network_site(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a network site.

GraphQL: mutation { updateNetworkSite }

Arguments

• id — GlobalID — The network site's unique identifier. Optional for backwards compatibility — prefer this over the deprecated input field.
• input — UpdateNetworkSiteInput! — The input required to update a network site.

@spec update_network_site_ip_block(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a network site IP block.

GraphQL: mutation { updateNetworkSiteIpBlock }

Arguments

• id — GlobalID — The network site IP block's unique identifier. Optional for backwards compatibility — prefer this over the deprecated input field.
• input — UpdateNetworkSiteIpBlockInput! — The updateNetworkSiteIpBlock mutation's input.

@spec update_note(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a note.

GraphQL: mutation { updateNote }

Arguments

• input — UpdateNoteInput! — The input required to update a note.

@spec update_payment_method(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a payment method.

GraphQL: mutation { updatePaymentMethod }

Arguments

• id — GlobalID! — The payment method's ID.
• input — UpdatePaymentMethodInput! — The input required to update the payment method.

@spec update_payments(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update payments' status.

GraphQL: mutation { updatePayments }

Arguments

• input — UpdatePaymentsInput! — The input required to update payments.

@spec update_product(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a product.

GraphQL: mutation { updateProduct }

Arguments

• id — GlobalID! — The product's ID.
• input — UpdateProductInput! — The updateProduct mutation's input.

@spec update_product_category(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a product category.

GraphQL: mutation { updateProductCategory }

Arguments

• id — GlobalID! — The product category's ID.
• input — UpdateProductCategoryInput! — The updateProductCategory mutation's input.

@spec update_property(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a property.

GraphQL: mutation { updateProperty }

Arguments

• id — GlobalID! — The property's unique id.
• input — UpdatePropertyInput! — The input required to update a property.

@spec update_property_contact(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a property's contact.

GraphQL: mutation { updatePropertyContact }

Arguments

• propertyId — GlobalID! — The property's unique ID.
• id — GlobalID! — The contact's unique ID.
• input — UpdatePropertyContactInput! — The input required to update a property's contact.

@spec update_property_group(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a property group.

GraphQL: mutation { updatePropertyGroup }

Arguments

• id — GlobalID! — The property group's unique ID.
• input — UpdatePropertyGroupInput! — The input required to update a property group.

@spec update_property_group_manager(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a property group manager.

GraphQL: mutation { updatePropertyGroupManager }

Arguments

• id — GlobalID! — The property group manager's unique ID.
• input — UpdatePropertyGroupManagerInput! — The input required to update a property group manager.

@spec update_property_physical_address(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a property's physical address.

GraphQL: mutation { updatePropertyPhysicalAddress }

Arguments

• id — GlobalID! — The property's unique id.
• input — UpdatePropertyPhysicalAddressInput! — The input required to update a property's physical address.

@spec update_role(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a role.

GraphQL: mutation { updateRole }

Arguments

• id — GlobalID! — The role's unique ID.
• input — UpdateRoleInput! — The input required to update a role.

@spec update_schedule_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing schedule template.

GraphQL: mutation { updateScheduleTemplate }

Arguments

• id — GlobalID! — The schedule template's global ID.
• input — UpdateScheduleTemplateInput! — The input required to update a schedule template.

@spec update_technician(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing technician.

GraphQL: mutation { updateTechnician }

Arguments

• id — GlobalID! — The technician's global ID.
• input — UpdateTechnicianInput! — The input required to update a technician.

@spec update_technician_team(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing technician team.

GraphQL: mutation { updateTechnicianTeam }

Arguments

• id — GlobalID! — The technician team's global ID.
• input — UpdateTechnicianTeamInput! — The input required to update a technician team.

@spec update_ticket_assignees(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a ticket's assignees.

GraphQL: mutation { updateTicketAssignees }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — UpdateTicketAssigneesInput! — The input required to update a ticket's assignees.

@spec update_ticket_comment(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a ticket comment.

GraphQL: mutation { updateTicketComment }

Arguments

• id — GlobalID! — The ticket comment's unique ID.
• input — UpdateTicketCommentInput! — The input required to update a ticket comment.

@spec update_ticket_followers(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a ticket's followers.

GraphQL: mutation { updateTicketFollowers }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — UpdateTicketFollowersInput! — The input required to update a ticket's followers.

@spec update_ticket_status(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a ticket's status.

GraphQL: mutation { updateTicketStatus }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — UpdateTicketStatusInput! — The input required to update a ticket's status.

@spec update_ticket_template(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a ticket template.

GraphQL: mutation { updateTicketTemplate }

Arguments

• id — GlobalID! — The ticket template's unique ID.
• input — UpdateTicketTemplateInput! — The input required to update a ticket template.

@spec update_ticket_work_order(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a ticket's work order.

GraphQL: mutation { updateTicketWorkOrder }

Arguments

• id — GlobalID! — The ticket's unique ID.
• input — UpdateTicketWorkOrderInput! — The input required to update a ticket's work order.

@spec update_time_blocker(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a time blocker.

GraphQL: mutation { updateTimeBlocker }

Arguments

• id — GlobalID — The time blocker's unique ID.
• input — UpdateTimeBlockerInput! — The updateTimeBlocker mutation's input.

@spec update_unit(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a unit.

GraphQL: mutation { updateUnit }

Arguments

• id — GlobalID! — The unit's unique ID.
• input — UpdateUnitInput! — The input required to update a unit.

@spec update_user(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a user.

GraphQL: mutation { updateUser }

Arguments

• id — GlobalID! — The user's unique ID.
• input — UpdateUserInput! — The input required to update a user.

@spec update_work_order(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing work order.

GraphQL: mutation { updateWorkOrder }

Arguments

• input — UpdateWorkOrderInput! — The input required to update a work order.

@spec update_work_order_custom_status(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update a work order custom status.

GraphQL: mutation { updateWorkOrderCustomStatus }

Arguments

• input — UpdateWorkOrderCustomStatusInput! — The input required to update a work order custom status.

@spec update_work_order_procedure_value(
  Gaiia.Client.t(),
  map(),
  String.t(),
  keyword()
) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update the procedure value of a work order.

GraphQL: mutation { updateWorkOrderProcedureValue }

Arguments

• input — UpdateWorkOrderProcedureValueInput! — The input required to update the procedure value.

@spec update_work_orders_status(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Updates the status of up to 250 work orders in bulk. Returns the updated work orders and any per-work-order errors (partial success).

GraphQL: mutation { updateWorkOrdersStatus }

Arguments

• input — UpdateWorkOrdersStatusInput! — The input required to update the status of multiple work orders.

@spec update_work_type(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing work type.

GraphQL: mutation { updateWorkType }

Arguments

• id — GlobalID! — The work type's global ID.
• input — UpdateWorkTypeInput! — The input required to update a work type.

@spec update_workflow_secret(Gaiia.Client.t(), map(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Gaiia.Error.t()}

Update an existing workflow secret.

GraphQL: mutation { updateWorkflowSecret }

Arguments

• id — GlobalID! — The workflow secrets's unique ID.
• input — UpdateWorkflowSecretInput! — The input required to update a workflow secret.