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

Query an account by unique ID.

GraphQL: query { account }

Arguments

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

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

Query an account by its readable ID.

GraphQL: query { accountByReadableId }

Arguments

• readableId — Int! — The account's readable ID.

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

Query a paginated list of account custom field definitions.

GraphQL: query { accountCustomFieldDefinitions }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.

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

Query a paginated list of account labels.

GraphQL: query { accountLabels }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [AccountLabelOrderBy!] — Orders the results by the given fields.
• filter — AccountLabelFilter — Filters the results.

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

Query a paginated list of account statuses.

GraphQL: query { accountStatuses }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — AccountStatusFilter — Filters the results.

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

Query a paginated list of account types.

GraphQL: query { accountTypes }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.

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

Query a paginated list of accounts.

GraphQL: query { accounts }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [AccountOrderBy!] — Orders the results by the given fields.
• filter — AccountFilter — Filters the results.

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

Query accounts in network sites by traversing device hierarchy.

GraphQL: query { accountsInNetworkSites }

Arguments

• filters — AccountsInNetworkSitesQueryFilters! — Filters to apply to the query.
• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.

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

Query a paginated list of address custom field definitions.

GraphQL: query { addressCustomFieldDefinitions }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — AddressCustomFieldDefinitionFilters — Filters to apply to the query.

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

Query a paginated list of addresses.

GraphQL: query { addresses }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — AddressesQueryFilter — Filters to apply to the query.
• orderBy — [AddressOrderBy!] — Order by which to sort results.

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

Retrieve the tenant's appointment settings, with arrival windows resolved for an optional work type.

GraphQL: query { appointmentSettings }

Arguments

• workTypeId — GlobalID — The work type whose custom arrival windows should be used. When omitted, or when the work type has no custom set, the tenant's default arrival windows are returned.

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

Query paginated list of archived product bundles.

GraphQL: query { archivedBundles }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — BundlesQueryFilters — Filters to apply to the query.

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

Query a paginated list of archived coverage areas.

GraphQL: query { archivedCoverageAreas }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — ArchivedCoverageAreasQueryFilter — Filters to apply to the query.

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

Query to get a list of archived inventory roles.

GraphQL: query { archivedInventoryRoles }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — ArchivedInventoryRolesQueryFilters — Filters to apply to the query

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

Query availabilities for auto-assignment with travel time constraints.

GraphQL: query { availabilitiesForAutoAssign }

Arguments

• input — AvailabilitiesForAutoAssignInput! — The input required to query availabilities for auto-assignment.

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

Query the available days for a work order.

GraphQL: query { availableDaysByWorkOrderId }

Arguments

• input — AvailableDaysByWorkOrderIdQueryInput! — The input required to query the available days for a work order.

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

Query the available start times for a work order.

GraphQL: query { availableStartTimesByWorkOrderId }

Arguments

• input — AvailableStartTimesByWorkOrderIdQueryInput! — The input required to query the available start times for a work order.

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

Query a paginated list of technicians available for a work order on a specified date.

GraphQL: query { availableTechniciansForWorkOrderAndStartDate }

Arguments

• first — Int — Return up to the first n technicians from the list.
• last — Int — Returns up to the last n technicians from the list.
• after — String — Returns the technicians that come after the specified cursor.
• before — String — Returns the technicians that come before the specified cursor.
• orderBy — [TechnicianOrderBy!] — Orders the results by the given fields.
• filter — TechnicianFilter — Filters the results.
• startDate — DateTime! — The start date of the work order to search for technicians.
• workOrderId — GlobalID! — The work order's ID.

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

Query a billing subscription by unique ID.

GraphQL: query { billingSubscription }

Arguments

• id — GlobalID! — The billing subscription's unique ID.

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

Query a paginated list of billing subscriptions. The arguments 'first' and 'last' are mutually exclusive; only one of them can be set at a time. The same applies to 'after' and 'before'.

GraphQL: query { billingSubscriptions }

Arguments

• before — String — Returns the elements that come before the specified cursor.
• after — String — Returns the elements that come after the specified cursor.
• first — Int — Returns up to the first 'n' elements from the list.
• last — Int — Returns up to the last 'n' elements from the list.
• filter — BillingSubscriptionsFilter — Filters the results.
• orderBy — [BillingSubscriptionsOrderBy!] — Orders the results by the given fields.

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

Get a bundle by its ID.

GraphQL: query { bundle }

Arguments

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

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

Query paginated list of product bundles.

GraphQL: query { bundles }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — BundlesQueryFilters — Filters to apply to the query.

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

Query a paginated list of cancellation reasons.

GraphQL: query { cancellationReasons }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — CancellationReasonFilter — Filter the cancellation reasons by category.

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

Query a paginated list of commercial account statuses.

GraphQL: query { commercialAccountStatuses }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — CommercialAccountStatusFilter — Filters the results.

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

Query a paginated list of commercial accounts. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { commercialAccounts }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [CommercialAccountOrderBy!] — Orders the results by the given fields.
• filter — CommercialAccountsFilter — Filters the results.

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

Query the full list of Communication Type Groups, ordered for display.

Note: intentionally returns a flat list rather than a Connection because this is a small, bounded, static global list that is always returned in full and never paginated.

GraphQL: query { communicationTypeGroups }

Takes no arguments.

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

Query a paginated list of coverage areas.

GraphQL: query { coverageAreas }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — CoverageAreasQueryFilter — Filters to apply to the query.

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

List all custom object definitions for the tenant. The arguments first and last are mutually exclusive; only one can be set at a time. The same applies to after and before.

GraphQL: query { customObjectDefinitions }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — CustomObjectDefinitionsFilters — Filters to apply.

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

Fetch a single custom object field definition by id.

GraphQL: query { customObjectField }

Arguments

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

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

List all field definitions for a custom object. The arguments first and last are mutually exclusive; only one can be set at a time. The same applies to after and before.

GraphQL: query { customObjectFields }

Arguments

• objectDefinitionId — GlobalID! — The object definition's unique identifier.
• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — CustomObjectFieldsFilters — Filters to apply.

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

Fetch a single custom object record by id.

GraphQL: query { customObjectRecord }

Arguments

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

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

List records for a custom object type. The arguments first and last are mutually exclusive; only one can be set at a time. The same applies to after and before.

GraphQL: query { customObjectRecords }

Arguments

• objectDefinitionId — GlobalID! — The object definition's unique identifier.
• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — CustomObjectRecordsFilters — Filters to apply.

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

Fetch multiple custom object records by their ids.

GraphQL: query { customObjectRecordsByIds }

Arguments

• ids — [GlobalID!]! — The record unique identifiers.

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

Query a paginated list of customer owned items.

GraphQL: query { customerOwnedItems }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — CustomerOwnedItemsQueryFilters — Filters to apply to the query.

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

Retrieve the default appointment configuration.

GraphQL: query { defaultAppointmentConfig }

Takes no arguments.

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

Get entity custom field definitions for a specific entity type.

GraphQL: query { entityCustomFieldDefinitions }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — EntityCustomFieldDefinitionFilter — Filters available for the query.

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

Query feature flags from AppConfig

GraphQL: query { featureFlags }

Takes no arguments.

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

Find an address.

GraphQL: query { findAddress }

Arguments

• input — FindAddressInput! — The input required to find an address.

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

Query an incident by unique ID.

GraphQL: query { incident }

Arguments

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

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

Query an incident procedure template.

GraphQL: query { incidentProcedureTemplate }

Arguments

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

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

Query a paginated list of incident procedure templates.

GraphQL: query { incidentProcedureTemplates }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.

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

Query a paginated list of incidents.

GraphQL: query { incidents }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — IncidentFilter — Filters the results.

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

GraphQL query integrationNone.

GraphQL: query { integrationNone }

Takes no arguments.

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

Query a single inventory item by its ID.

GraphQL: query { inventoryItem }

Arguments

• id — GlobalID! — The global ID of the inventory item to retrieve.

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

Query a paginated list of inventory items.

GraphQL: query { inventoryItems }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — InventoryItemsQueryFilters — Filters to apply to the query.

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

Query to get a list of inventory locations.

GraphQL: query { inventoryLocations }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — InventoryLocationsQueryFilters — Filters to apply to the query.

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

Query to get all inventory model categories.

GraphQL: query { inventoryModelCategories }

Arguments

• first — Int — Returns up to the first n elements from the list.
• before — String — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• last — Int — Returns the elements that come before the specified cursor.

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

Query to get a list of inventory models.

GraphQL: query { inventoryModels }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — InventoryModelQueryFilters — Filters to apply to the query.

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

Query to get a list of inventory roles.

GraphQL: query { inventoryRoles }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — InventoryRolesQueryFilters — Filters to apply to the query

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

Query an invoice by unique ID.

GraphQL: query { invoice }

Arguments

• id — GlobalID! — The invoice's unique Id.

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

Query a paginated list of billing invoices. The arguments 'first' and 'last' are mutually exclusive; only one of them can be set at a time. The same applies to 'after' and 'before'.

GraphQL: query { invoices }

Arguments

• before — String — Returns the elements that come before the specified cursor.
• first — Int — Returns up to the first 'n' elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• last — Int — Returns up to the last 'n' elements from the list.
• filter — InvoicesFilter — Filters the results.

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

Query to get a list of manufacturers.

GraphQL: query { manufacturers }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — ManufacturersQueryFilters — Filters to apply to the query

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

Query a network site by unique ID.

GraphQL: query { networkSite }

Arguments

• id — GlobalID! — The network site's unique ID.

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

Query to get a list of network sites.

GraphQL: query { networkSites }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filters — NetworkSiteFilters — Filters to apply to the query.
• orderBy — [NetworkSiteOrderBy!] — Orders the results by the given fields.

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

Query a note by unique ID.

GraphQL: query { note }

Arguments

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

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

Query a paginated list of notes.

GraphQL: query { notes }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — NoteFilter — Filters the results.

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

Get a paginated list of notifications. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { notifications }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — NotificationsFilter — Filters the results.
• orderBy — [NotificationOrderBy!] — Ordering of the results.

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

Query an order by unique ID.

GraphQL: query { order }

Arguments

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

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

Query an order attribution profile by unique ID.

GraphQL: query { orderAttributionProfile }

Arguments

• id — GlobalID! — The order attribution profile's unique ID.

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

Query a paginated list of order attribution profiles. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { orderAttributionProfiles }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• searchTerm — String — Search by profile name.
• filter — OrderAttributionProfileFilter — Filters the results.

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

Query a paginated list of orders. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { orders }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — OrderFilter — Filters the results.
• orderBy — [OrderOrderBy!] — Orders the results by the given fields.

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

Query a paginated list of payment methods. The arguments 'first' and 'last' are mutually exclusive; only one of them can be set at a time. The same applies to 'after' and 'before'.

GraphQL: query { paymentMethods }

Arguments

• before — String — Returns the elements that come before the specified cursor.
• first — Int — Returns up to the first 'n' elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• last — Int — Returns up to the last 'n' elements from the list.
• filter — PaymentMethodsFilter — Filters the results.

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

Query the PIN verification status for an entity.

GraphQL: query { pinVerification }

Arguments

• entityId — GlobalID! — The entity to check verification status for.

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

Query a plan service area by unique ID.

GraphQL: query { plannedServiceArea }

Arguments

• id — GlobalID! — The plan service area's unique ID.

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

Query a planned service area by unique slug.

GraphQL: query { plannedServiceAreaBySlug }

Arguments

• slug — String! — The planned service area's unique slug.

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

Health check endpoint for platform service

GraphQL: query { platformServiceHealthCheck }

Takes no arguments.

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

GraphQL query platformServiceNone.

GraphQL: query { platformServiceNone }

Takes no arguments.

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

Preview the schedule events that would be generated from an existing schedule template.

GraphQL: query { previewScheduleForScheduleTemplateId }

Arguments

• input — PreviewScheduleForScheduleTemplateIdInput! — The previewScheduleForScheduleTemplateId query's input.

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

Retrieve a product availability job by its ID. Requires a gaiia publishable key in the request headers.

GraphQL: query { productAvailabilityJob }

Arguments

• id — GlobalID! — ID of the product availability job to retrieve.

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

Get a product by slug. If the slug is not current, attempts to resolve it using product slug history.

GraphQL: query { productBySlug }

Arguments

• slug — String! — The product slug from the URL.

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

Query paginated list of product categories.

GraphQL: query { productCategories }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.

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

Get a productVersion by its ID.

GraphQL: query { productVersion }

Arguments

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

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

Query paginated list of product versions.

GraphQL: query { productVersions }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — ProductVersionFilter — Filter the results.

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

Query paginated list of products.

GraphQL: query { products }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — ProductFilter — Filter the results.

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

Query a list of properties.

GraphQL: query { properties }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [PropertyOrderBy!] — Orders the results by the given fields.
• filter — PropertyFilter — Filters the results.

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

Query a property by unique ID.

GraphQL: query { property }

Arguments

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

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

Query a property group by unique ID.

GraphQL: query { propertyGroup }

Arguments

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

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

Query a paginated list of property groups.

GraphQL: query { propertyGroups }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [PropertyGroupOrderBy!] — Orders the results by the given fields.
• filter — PropertyGroupFilter — Filters the results.

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

Evaluates product version and bundle eligibility against a set of selected product versions.

GraphQL: query { resolveProductEligibility }

Arguments

• availableProductVersionIds — [GlobalID!]! — The IDs of the product versions that are available at the address.
• availableBundleIds — [GlobalID!]! — The IDs of the bundles that are available at the address.
• selectedProductVersionIds — [GlobalID!]! — The IDs of the product versions the customer currently has selected.

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

Query a role by unique ID.

GraphQL: query { role }

Arguments

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

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

Query a paginated list of roles. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before. Only the first orderBy entry is applied.

GraphQL: query { roles }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — RoleFilter — Filters the results.
• orderBy — [RoleOrderBy!] — Orders the results by the given field. Only the first entry is applied.

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

Query a schedule template by unique ID.

GraphQL: query { scheduleTemplate }

Arguments

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

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

Query a paginated list of schedule templates. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { scheduleTemplates }

Arguments

• first — Int — Return up to the first n schedule templates from the list.
• last — Int — Returns up to the last n schedule templates from the list.
• after — String — Returns the schedule templates that come after the specified cursor.
• before — String — Returns the schedule templates that come before the specified cursor.
• orderBy — [WorkforceScheduleTemplateOrderBy!] — Orders the results by the given fields.
• filter — WorkforceScheduleTemplateFilter — Filters the results.

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

Search entities by a query string.

GraphQL: query { searchEntities }

Arguments

• query — String! — The search query string.
• entityTypes — [SearchEntityType!] — The types of entities to search for. If not provided, all types are searched.
• limit — Int — The maximum number of results to return.

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

Query a paginated list of tag definitions.

GraphQL: query { tagDefinitions }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — TagDefinitionsFilter — Filters the results.

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

Query technician availability analytics with filters for coverage area, work type, and date range.

GraphQL: query { technicianAvailabilityAnalytics }

Arguments

• input — TechnicianAvailabilityAnalyticsInput! — Input filters for the analytics query.

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

Query a single technician team by its global ID.

GraphQL: query { technicianTeamById }

Arguments

• id — GlobalID! — The technician team's global ID.

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

Query a paginated list of technician teams. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { technicianTeams }

Arguments

• first — Int — Return up to the first n technician teams from the list.
• last — Int — Returns up to the last n technician teams from the list.
• after — String — Returns the technician teams that come after the specified cursor.
• before — String — Returns the technician teams that come before the specified cursor.
• orderBy — [TechnicianTeamOrderBy!] — Orders the results by the given fields.
• filter — TechnicianTeamFilter — Filters the results.

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

Query a paginated list of technicians.

GraphQL: query { technicians }

Arguments

• first — Int — Return up to the first n technicians from the list.
• last — Int — Returns up to the last n technicians from the list.
• after — String — Returns the technicians that come after the specified cursor.
• before — String — Returns the technicians that come before the specified cursor.
• orderBy — [TechnicianOrderBy!] — Orders the results by the given fields.
• filter — TechnicianFilter — Filters the results.

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

Query a ticket by unique ID.

GraphQL: query { ticket }

Arguments

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

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

Query a ticket by its readable ID.

GraphQL: query { ticketByReadableId }

Arguments

• readableId — Int! — The ticket's readable ID.

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

Query paginated list of ticket categories.

GraphQL: query { ticketCategories }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [TicketCategoryOrderBy!] — Orders the results by the given fields.
• filter — TicketCategoryFilter — Filters the results.

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

Query paginated list of ticket closed reasons.

GraphQL: query { ticketClosedReasons }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [TicketClosedReasonOrderBy!] — Orders the results by the given fields.
• filter — TicketClosedReasonFilter — Filters the results.

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

Query paginated list of ticket custom statuses.

GraphQL: query { ticketCustomStatuses }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [TicketCustomStatusOrderBy!] — Orders the results by the given fields.
• filter — TicketCustomStatusFilter — Filters the results.

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

Query paginated list of ticket mailboxes.

GraphQL: query { ticketMailboxes }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.

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

Query paginated list of ticket templates.

GraphQL: query { ticketTemplates }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [TicketTemplateOrderBy!] — Orders the results by the given fields.
• filter — TicketTemplateFilter — Filters the results.

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

Query paginated list of ticket types.

GraphQL: query { ticketTypes }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [TicketTypeOrderBy!] — Orders the results by the given fields.
• filter — TicketTypeFilter — Filters the results.

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

Query paginated list of tickets.

GraphQL: query { tickets }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [TicketOrderBy!] — Orders the results by the given fields.
• filter — TicketFilter — Filters the results.

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

Query a time blocker by unique ID.

GraphQL: query { timeBlocker }

Arguments

• id — GlobalID! — The time blocker's unique ID.

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

Query a time blocker by readable ID.

GraphQL: query { timeBlockerByReadableId }

Arguments

• readableId — Int! — The time blocker's readable ID.

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

Query a paginated list of time blockers.

GraphQL: query { timeBlockers }

Arguments

• first — Int — Return up to the first n time blockers from the list.
• last — Int — Returns up to the last n time blockers from the list.
• after — String — Returns the time blockers that come after the specified cursor.
• before — String — Returns the time blockers that come before the specified cursor.
• filter — TimeBlockerFilter — Filters the results.

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

Query a transaction by unique ID.

GraphQL: query { transaction }

Arguments

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

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

Query a unit by unique id.

GraphQL: query { unit }

Arguments

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

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

Query a list of units.

GraphQL: query { units }

Arguments

• first — Int — Returns the first n elements from the list.
• last — Int — Returns the last n elements from the list.
• before — String — Returns the elements that come after the specified cursor.
• after — String — Returns the elements that come before the specified cursor.
• orderBy — [UnitOrderBy!] — Orders the results by the given fields.
• filter — UnitFilter — Filters the results.

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

Query a paginated list of usage records. The arguments 'first' and 'last' are mutually exclusive; only one of them can be set at a time. The same applies to 'after' and 'before'.

GraphQL: query { usageRecords }

Arguments

• before — String — Returns the elements that come before the specified cursor.
• first — Int — Returns up to the first 'n' elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• last — Int — Returns up to the last 'n' elements from the list.
• filter — UsageRecordsFilter — Filters the results.

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

Query a user by unique ID.

GraphQL: query { user }

Arguments

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

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

Query a paginated list of users. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before. Only the first orderBy entry is applied.

GraphQL: query { users }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — UserFilter — Filters the results.
• orderBy — [UserOrderBy!] — Orders the results by the given field. Only the first entry is applied.

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

Query a webhook by unique ID.

GraphQL: query { webhook }

Arguments

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

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

Query a webhook execution by unique ID.

GraphQL: query { webhookExecution }

Arguments

• id — GlobalID! — The webhook execution's unique ID.

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

Query a paginated list of webhooks. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { webhooks }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [WebhookOrderBy!] — Orders the results by the given fields.
• filter — WebhookFilter — Filters the results.

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

Query work order custom status category analytics with filters for coverage area, work type, and date range.

GraphQL: query { workOrderCustomStatusCategoryAnalytics }

Arguments

• input — WorkOrderCustomStatusCategoryAnalyticsInput! — Input filters for the analytics query.

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

Query a paginated list of work order custom statuses.

GraphQL: query { workOrderCustomStatuses }

Arguments

• first — Int — Return up to the first n work order custom statuses from the list.
• last — Int — Returns up to the last n work order custom statuses from the list.
• after — String — Returns the work order custom statuses that come after the specified cursor.
• before — String — Returns the work order custom statuses that come before the specified cursor.
• orderBy — [WorkOrderCustomStatusOrderBy!] — Orders the results by the given fields.
• filter — WorkOrderCustomStatusFilter — Filters the results.

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

Query work order status analytics with filters for coverage area, work type, and date range.

GraphQL: query { workOrderStatusAnalytics }

Arguments

• input — WorkOrderStatusAnalyticsInput! — Input filters for the analytics query.

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

Query work order counts grouped by custom status category.

GraphQL: query { workOrderStatusCountsByCategory }

Takes no arguments.

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

Query a paginated list of work orders.

GraphQL: query { workOrders }

Arguments

• first — Int — Return up to the first n work orders from the list.
• last — Int — Returns up to the last n work orders from the list.
• after — String — Returns the work orders that come after the specified cursor.
• before — String — Returns the work orders that come before the specified cursor.
• orderBy — [WorkOrderOrderBy!] — Orders the results by the given fields.
• filter — WorkOrderFilter — Filters the results.

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

Query a paginated list of work types.

GraphQL: query { workTypes }

Arguments

• first — Int — Return up to the first n work types from the list.
• last — Int — Returns up to the last n work types from the list.
• after — String — Returns the work types that come after the specified cursor.
• before — String — Returns the work types that come before the specified cursor.
• orderBy — [WorkTypeOrderBy!] — Orders the results by the given fields.
• filter — WorkTypeFilter — Filters the results.

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

Query a workflow definition by unique ID.

GraphQL: query { workflowDefinition }

Arguments

• id — GlobalID! — The workflow definition's unique ID.

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

Query a workflow execution by unique ID.

GraphQL: query { workflowExecution }

Arguments

• id — GlobalID! — The workflow execution's unique ID.

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

Query a paginated list of workflow executions. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { workflowExecutions }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• filter — WorkflowExecutionFilter — Filters the results.
• orderBy — [WorkflowExecutionOrderBy!] — Orders the results by the given fields.

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

Query a workflow node execution by unique ID.

GraphQL: query { workflowNodeExecution }

Arguments

• id — GlobalID! — The workflow node execution's unique ID.

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

Query a workflow node execution result by unique ID.

GraphQL: query { workflowNodeExecutionResult }

Arguments

• id — GlobalID! — The workflow node execution result's unique ID.

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

Query a paginated list of workflow secrets. The arguments 'first' and 'last' are mutually exclusive; only one of them can be set at a time. The same applies to 'after' and 'before'.

GraphQL: query { workflowSecrets }

Arguments

• first — Int — Returns up to the first 'n' elements from the list.
• last — Int — Returns up to the last 'n' elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [WorkflowSecretOrderBy!] — Orders the results by the given fields.
• filter — WorkflowSecretFilter — Filters the results.

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

Query a paginated list of workflow variables. The arguments 'first' and 'last' are mutually exclusive; only one of them can be set at a time. The same applies to 'after' and 'before'.

GraphQL: query { workflowVariables }

Arguments

• first — Int — Returns up to the first 'n' elements from the list.
• last — Int — Returns up to the last 'n' elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [WorkflowVariableOrderBy!] — Orders the results by the given fields.
• filter — WorkflowVariableFilter — Filters the results.

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

Query a paginated list of workflows. The arguments first and last are mutually exclusive; only one of them can be set at a time. The same applies to after and before.

GraphQL: query { workflows }

Arguments

• first — Int — Returns up to the first n elements from the list.
• last — Int — Returns up to the last n elements from the list.
• after — String — Returns the elements that come after the specified cursor.
• before — String — Returns the elements that come before the specified cursor.
• orderBy — [WorkflowOrderBy!] — Orders the results by the given fields.
• filter — WorkflowFilter — Filters the results.

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

Query workforce overview statistics.

GraphQL: query { workforceOverviewStatistics }

Takes no arguments.